The necessity rows up to â #
Annotated results are compared up to â: rows annotated đ are
dropped, and so are the occurrences annotated đ inside aggregate values.
GeneratesAnnZ is GeneratesAnn with that comparison in place of
equality, so a set generating up to â need not reproduce the rows a
query annotates đ. This module proves the rows of the annotated basis
against it.
- The comparison (
GenRow.zeroNorm) keeps the rows whose annotation is notđand reads each aggregate column in the world of its occurrences annotated otherwise (GenRow.zeroTuple). It reads a token's value and not the token, so it is coarser than the comparison by occurrence identity (GenRow.zeqRen) on results that carry aggregate values: generating up to that one generates up to this one, and the rows below are the stronger statements. - The rows inherited from the plain basis cannot go through the
data part: a match may annotate
đrows the plain result does not hold. They go through the Boolean support instead. Overđč(BoolNone, Boolean functions of no variable) the rowsâkeeps are the realized world of an evaluation, which is the plain evaluation of the realized world (AggQueryIn.genRandomWorld_evaluate), and an instance annotatedđrealizes itself (generatesAtNoExplode_of_generatesAnnZ). It also needs the match to settle plainly on the realized world, whichAggQueryIn.settlesAt_randomWorldproves from its annotated settling. - The scope is the whole algebra, second-level aggregation at every storey included: the random-world theorem holds there, a nested world deciding each inner occurrence once.
- The rows proved over
â,â Ă âandâ[x, y]go through as they were: their witnesses' rows are annotated otherwise thanđ, soâkeeps them (GenRow.exists_finalize_of_zeroNorm).
annEpsOps_isBasis_in_class_approx is the basis theorem up to â over
the class AnnBasisClass, which holds đč, â and â[x, y]: the nine
classes generate (generatesAnnZ_annEpsOps_of_class, the constructions
agreeing with their source row by row up to finalization), and no proper
subset does (annEpsOps_minimal_in_class_approx).
Plain settling on the realized world #
The closed form: an empty environment.
Dependency graph
The comparison up to â #
A row's tuple with the occurrences annotated đ dropped: each
aggregate column read in the world of its occurrences annotated otherwise.
Equations
- GenRow.zeroTuple u k = Sum.elim id (fun (a : AggTok T K) => AggTok.specialize (fun (x : K) => decide (x â 0)) a) (u k)
Instances For
Dependency graph
An evaluation up to â: its rows annotated otherwise than đ,
with the occurrences annotated đ dropped from their aggregate values.
Equations
- GenRow.zeroNorm R = Multiset.map (fun (r : GenRow T K n) => (GenRow.zeroTuple r.1, r.2.finalize)) (Multiset.filter (fun (r : GenRow T K n) => r.2.finalize â 0) R)
Instances For
Dependency graph
A row annotated otherwise than đ on one side has a row of the same
annotation on the other.
Dependency graph
A set of classes generates the annotated algebra up to â: every
query of the whole algebra in the minimal universe is matched over the
set, by a query of the same fragment, whose result agrees with the
source's up to â wherever the source settles. The Boolean support of an
evaluation is the plain evaluation of the realized world
(AggQueryIn.genRandomWorld_evaluate), which is how the rows inherited
from the plain basis transfer.
Equations
- One or more equations did not get rendered due to their size.
Instances For
Dependency graph
The inherited rows, through the Boolean support #
đč, as Boolean functions of no variable: ÎŽ is the identity, and
an annotation is đ exactly where it is false.
Instances For
Dependency graph
Equations
- instHasAltLinearOrderBoolNone = { altOrder := linearOrderOfSTO WellOrderingRel }
Dependency graph
The transfer to the plain semantics, up to â: a set generating the
annotated algebra over đč up to â generates, plainly and without
reading aggregate columns as keys, every faithful query. Over đč the
rows â keeps are the realized world of an evaluation, which is the
plain evaluation of the realized world
(AggQueryIn.genRandomWorld_evaluate), and an instance annotated đ
realizes itself.
Dependency graph
The rows up to â #
The basis up to â #
No proper subset of the nine classes generates the annotated algebra
up to â over every semiring of the class, with the counting aggregate:
đč carries the rows inherited from the plain basis, â the Δ row and
â[x, y] the difference's.
Dependency graph
The positive half up to â #
The nine classes generate the annotated algebra up to â over every
semiring of the class: the constructions agree with their source row by
row up to finalization (exists_annEpsOps_match), which is what â
reads.
Dependency graph
The annotated basis theorem up to â, over the class: the nine
classes generate the annotated algebra up to â over every semiring of
AnnBasisClass, and no proper subset of them does over all of those semirings.