phanerozoic/Coq-AACTactics · Datasets at Hugging Face

fact stringlengths 16 1.35k	type stringclasses 10 values	library stringclasses 1 value	imports listlengths 1 4	filename stringclasses 5 values	symbolic_name stringlengths 1 23
sigma := PositiveMap.t.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	sigma
sigma_get A (null : A) (map : sigma A) (n : positive) : A := match PositiveMap.find n map with \| None => null \| Some x => x end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	sigma_get
sigma_add := @PositiveMap.add.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	sigma_add
sigma_empty := @PositiveMap.empty. Register sigma_get as aac_tactics.sigma.get. Register sigma_add as aac_tactics.sigma.add. Register sigma_empty as aac_tactics.sigma.empty.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	sigma_empty
Associative (X : Type) (R : relation X) (dot : X -> X -> X) := law_assoc : forall x y z, R (dot x (dot y z)) (dot (dot x y) z).	Class	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	Associative
Commutative (X : Type) (R : relation X) (plus : X -> X -> X) := law_comm: forall x y, R (plus x y) (plus y x).	Class	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	Commutative
Idempotent (X : Type) (R : relation X) (plus : X -> X -> X) := law_idem: forall x, R (plus x x) x.	Class	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	Idempotent
Unit (X : Type) (R : relation X) (op : X -> X -> X) (unit : X) := { law_neutral_left: forall x, R (op unit x) x; law_neutral_right: forall x, R (op x unit) x }. Register Associative as aac_tactics.classes.Associative. Register Commutative as aac_tactics.classes.Commutative. Register Idempotent as aac_tactics.classes.Idempotent. Register Unit as aac_tactics.classes.Unit. (**	Class	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	Unit
used to find the equivalence relation on which operations are A or AC, starting from the relation appearing in the goal *)	Class	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	used
AAC_lift (X : Type) (R : relation X) (E : relation X) := { aac_lift_equivalence : Equivalence E; aac_list_proper : Proper (E ==> E ==> iff) R }. Register AAC_lift as aac_tactics.internal.AAC_lift. Register aac_lift_equivalence as aac_tactics.internal.aac_lift_equivalence. (** Simple instances for when we have a subrelation or an equivalence ) #[export] Instance aac_lift_subrelation {X} {R} {E} {HE: Equivalence E} {HR: @Transitive X R} {HER: subrelation E R} : AAC_lift R E \| 3. Proof. constructor; trivial. intros ? ? H ? ? H'. split; intro G. rewrite <- H, G. apply HER, H'. rewrite H, G. apply HER. symmetry. apply H'. Qed. #[export] Instance aac_lift_proper {X} {R : relation X} {E} {HE: Equivalence E} {HR: Proper (E==>E==>iff) R} : AAC_lift R E \| 4 := {}. (* ** Utilities for the evaluation function *)	Class	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	AAC_lift
copy' n x := match n with \| xH => x \| xI n => let xn := copy' n x in plus (plus xn xn) x \| xO n => let xn := copy' n x in (plus xn xn) end.	Fixpoint	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	copy'
copy n x := Prect (fun _ => X) x (fun _ xn => plus x xn) n.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	copy
copy_plus : forall n m x, R (copy (n+m) x) (plus (copy n x) (copy m x)). Proof. unfold copy. induction n using Pind; intros m x. rewrite Prect_base. rewrite <- Pplus_one_succ_l. rewrite Prect_succ. reflexivity. rewrite Pplus_succ_permute_l. rewrite 2Prect_succ. rewrite IHn. apply op. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	copy_plus
copy_xH : forall x, R (copy 1 x) x. Proof. intros; unfold copy; rewrite Prect_base. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	copy_xH
copy_Psucc : forall n x, R (copy (Pos.succ n) x) (plus x (copy n x)). Proof. intros; unfold copy; rewrite Prect_succ. reflexivity. Qed. #[export] Instance copy_compat n : Proper (R ==> R) (copy n). Proof. unfold copy. induction n using Pind; intros x y H. rewrite 2Prect_base. assumption. rewrite 2Prect_succ. apply po; auto. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	copy_Psucc
type_of (n: nat) := match n with \| O => X \| S n => X -> type_of n end. (** Relation to be preserved at an arity *)	Fixpoint	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	type_of
rel_of n : relation (type_of n) := match n with \| O => R \| S n => respectful R (rel_of n) end. Register type_of as aac_tactics.internal.sym.type_of. Register rel_of as aac_tactics.internal.sym.rel_of. (** A symbol package contains: - an arity, - a value of the corresponding type, and - a proof that the value is a proper morphism *)	Fixpoint	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	rel_of
pack : Type := mkPack { ar : nat; value :> type_of ar; morph : Proper (rel_of ar) value }. Register pack as aac_tactics.sym.pack. Register mkPack as aac_tactics.sym.mkPack. (** Helper to build default values, when filling reification environments *)	Record	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	pack
null : pack := mkPack 1 (fun x => x) (fun _ _ H => H). Register null as aac_tactics.sym.null.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	null
pack := mk_pack { value:> X -> X -> X; compat: Proper (R ==> R ==> R) value; assoc: Associative R value; comm: option (Commutative R value); idem: option (Idempotent R value) }. Register pack as aac_tactics.bin.pack. Register mk_pack as aac_tactics.bin.mkPack.	Record	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	pack
unit_of u := mk_unit_for { uf_idx: idx; uf_desc: Unit R (Bin.value (e_bin uf_idx)) u }.	Record	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	unit_of
unit_pack := mk_unit_pack { u_value:> X; u_desc: list (unit_of u_value) }. Register unit_of as aac_tactics.internal.unit_of. Register mk_unit_for as aac_tactics.internal.mk_unit_for. Register unit_pack as aac_tactics.internal.unit_pack. Register mk_unit_pack as aac_tactics.internal.mk_unit_pack. Variable e_unit: positive -> unit_pack. #[local] Hint Resolve e_bin e_unit: typeclass_instances. ( * Almost normalised syntax A term in [T] is in normal form if: - sums do not contain sums - products do not contain products - there are no unary sums or products - lists and msets are lexicographically sorted according to the order we define below [vT n] denotes the set of term vectors of size <<n>> (the mutual dependency could be removed). Note that [T] and [vT] depend on the [e_sym] environment (which contains, among other things, the arity of symbols). *)	Record	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	unit_pack
T : Type := \| sum: idx -> mset T -> T \| prd: idx -> nelist T -> T \| sym: forall i, vT (Sym.ar (e_sym i)) -> T \| unit : idx -> T with vT: nat -> Type := \| vnil: vT O \| vcons: forall n, T -> vT n -> vT (S n). Register T as aac_tactics.internal.T. Register sum as aac_tactics.internal.sum. Register prd as aac_tactics.internal.prd. Register sym as aac_tactics.internal.sym. Register unit as aac_tactics.internal.unit. Register vnil as aac_tactics.internal.vnil. Register vcons as aac_tactics.internal.vcons. (** Lexicographic rpo over the normalised syntax *)	Inductive	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	T
compare (u v: T) := match u,v with \| sum i l, sum j vs => lex (Pos.compare i j) (mset_compare compare l vs) \| prd i l, prd j vs => lex (Pos.compare i j) (list_compare compare l vs) \| sym i l, sym j vs => lex (Pos.compare i j) (vcompare l vs) \| unit i , unit j => Pos.compare i j \| unit _ , _ => Lt \| _ , unit _ => Gt \| sym _ _, _ => Lt \| _ , sym _ _ => Gt \| prd _ _, _ => Lt \| _ , prd _ _ => Gt end with vcompare i j (us: vT i) (vs: vT j) := match us,vs with \| vnil, vnil => Eq \| vnil, _ => Lt \| _, vnil => Gt \| vcons _ u us, vcons _ v vs => lex (compare u v) (vcompare us vs) end. ( * Evaluation from syntax to the abstract domain *)	Fixpoint	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	compare
eval u: X := match u with \| sum i l => let o := Bin.value (e_bin i) in fold_map (fun un => let '(u,n):=un in @copy _ o n (eval u)) o l \| prd i l => fold_map eval (Bin.value (e_bin i)) l \| sym i v => eval_aux v (Sym.value (e_sym i)) \| unit i => e_unit i end with eval_aux i (v: vT i): Sym.type_of i -> X := match v with \| vnil => fun f => f \| vcons _ u v => fun f => eval_aux v (f (eval u)) end. Register eval as aac_tactics.internal.eval. (** We need to show that [compare] reflects equality (this is because we work with msets rather than with lists with arities) *)	Fixpoint	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval
tcompare_weak_spec u : forall (v : T), compare_weak_spec u v (compare u v) with vcompare_reflect_eqdep i us : forall j vs (H: i=j), vcompare us vs = Eq -> cast vT H us = vs. Proof. induction u. - destruct v; simpl; try constructor. case (pos_compare_weak_spec p p0); intros; try constructor. case (mset_compare_weak_spec compare tcompare_weak_spec m m0); intros; try constructor. - destruct v; simpl; try constructor. case (pos_compare_weak_spec p p0); intros; try constructor. case (list_compare_weak_spec compare tcompare_weak_spec n n0); intros; try constructor. - destruct v0; simpl; try constructor. case_eq (Pos.compare i i0); intro Hi; try constructor. (* the [symmetry] is required ) apply pos_compare_reflect_eq in Hi. symmetry in Hi. subst. case_eq (vcompare v v0); intro Hv; try constructor. rewrite <- (vcompare_reflect_eqdep _ _ _ _ eq_refl Hv). constructor. - destruct v; simpl; try constructor. case_eq (Pos.compare p p0); intro Hi; try constructor. apply pos_compare_reflect_eq in Hi. symmetry in Hi. subst. constructor. - induction us; destruct vs; simpl; intros H Huv; try discriminate. apply cast_eq, eq_nat_dec. injection H; intro Hn. revert Huv; case (tcompare_weak_spec t t0); intros; try discriminate. ( the [symmetry] is required *) symmetry in Hn. subst. rewrite <- (IHus _ _ eq_refl Huv). apply cast_eq, eq_nat_dec. Qed.	Fixpoint	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	tcompare_weak_spec
eval_aux_compat i (l: vT i): Proper (@Sym.rel_of X R i ==> R) (eval_aux l). Proof. induction l; simpl; repeat intro. assumption. apply IHl, H. reflexivity. Qed. (** Is <<i>> a unit for <<j>>? *)	Instance	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval_aux_compat
is_unit_of j i := List.existsb (fun p => eq_idx_bool j (uf_idx p)) (u_desc (e_unit i)). (** Is <<i>> commutative? *)	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	is_unit_of
is_commutative i := match Bin.comm (e_bin i) with Some _ => true \| None => false end. (** Is <<i>> idempotent? *)	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	is_commutative
is_idempotent i := match Bin.idem (e_bin i) with Some _ => true \| None => false end. ( * Normalisation *) #[universes(template)]	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	is_idempotent
discr {A} : Type := \| Is_op : A -> discr \| Is_unit : idx -> discr \| Is_nothing : discr. (** This is called [Datatypes.sum] in the stdlib *) #[universes(template)]	Inductive	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	discr
m {A} {B} := \| left : A -> m \| right : B -> m.	Inductive	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	m
comp A B (merge : B -> B -> B) (l : B) (l' : @m A B) : @m A B := match l' with \| left _ => right l \| right l' => right (merge l l') end. (** Auxiliary functions, to clean up sums *)	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	comp
sum' (u: mset T): T := match u with \| nil (u,xH) => u \| _ => sum i u end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	sum'
is_sum (u: T) : @discr (mset T) := match u with \| sum j l => if eq_idx_bool j i then Is_op l else Is_nothing \| unit j => if is_unit j then Is_unit j else Is_nothing \| _ => Is_nothing end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	is_sum
copy_mset n (l: mset T): mset T := match n with \| xH => l \| _ => nelist_map (fun vm => let '(v,m):=vm in (v,Pmult n m)) l end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	copy_mset
return_sum u n := match is_sum u with \| Is_nothing => right (nil (u,n)) \| Is_op l' => right (copy_mset n l') \| Is_unit j => left j end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	return_sum
add_to_sum u n (l : @m idx (mset T)) := match is_sum u with \| Is_nothing => comp (merge_msets compare) (nil (u,n)) l \| Is_op l' => comp (merge_msets compare) (copy_mset n l') l \| Is_unit _ => l end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	add_to_sum
norm_msets_ norm (l: mset T) := fold_map' (fun un => let '(u,n) := un in return_sum (norm u) n) (fun un l => let '(u,n) := un in add_to_sum (norm u) n l) l.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	norm_msets_
prd' (u: nelist T): T := match u with \| nil u => u \| _ => prd i u end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	prd'
is_prd (u: T) : @discr (nelist T) := match u with \| prd j l => if eq_idx_bool j i then Is_op l else Is_nothing \| unit j => if is_unit j then Is_unit j else Is_nothing \| _ => Is_nothing end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	is_prd
return_prd u := match is_prd u with \| Is_nothing => right (nil (u)) \| Is_op l' => right (l') \| Is_unit j => left j end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	return_prd
add_to_prd u (l : @m idx (nelist T)) := match is_prd u with \| Is_nothing => comp (@appne T) (nil (u)) l \| Is_op l' => comp (@appne T) (l') l \| Is_unit _ => l end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	add_to_prd
norm_lists_ norm (l : nelist T) := fold_map' (fun u => return_prd (norm u)) (fun u l => add_to_prd (norm u) l) l.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	norm_lists_
run_list x := match x with \| left n => nil (unit n) \| right l => l end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	run_list
norm_lists norm i l := let is_unit := is_unit_of i in run_list (norm_lists_ i is_unit norm l).	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	norm_lists
run_msets x := match x with \| left n => nil (unit n, xH) \| right l => l end.	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	run_msets
norm_msets norm i l := let is_unit := is_unit_of i in run_msets (norm_msets_ i is_unit norm l).	Definition	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	norm_msets
norm u {struct u}:= match u with \| sum i l => if is_commutative i then if is_idempotent i then sum' i (reduce_mset (norm_msets norm i l)) else sum' i (norm_msets norm i l) else u \| prd i l => prd' i (norm_lists norm i l) \| sym i l => sym i (vnorm l) \| unit i => unit i end with vnorm i (l: vT i): vT i := match l with \| vnil => vnil \| vcons _ u l => vcons (norm u) (vnorm l) end. ( * Correctness *)	Fixpoint	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	norm
is_unit_of_Unit : forall i j : idx, is_unit_of i j = true -> Unit R (Bin.value (e_bin i)) (eval (unit j)). Proof. intros. unfold is_unit_of in H. rewrite existsb_exists in H. destruct H as [x [H H']]. revert H' ; case (eq_idx_spec); [intros H' _ ; subst\| intros _ H'; discriminate]. simpl. destruct x. simpl. auto. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	is_unit_of_Unit
Binvalue_Commutative i (H : is_commutative i = true) : Commutative R (@Bin.value _ _ (e_bin i) ). Proof. unfold is_commutative in H. destruct (Bin.comm (e_bin i)); auto. discriminate. Qed.	Instance	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	Binvalue_Commutative
Binvalue_Idempotent i (H : is_idempotent i = true) : Idempotent R (@Bin.value _ _ (e_bin i)). Proof. unfold is_idempotent in H. destruct (Bin.idem (e_bin i)); auto. discriminate. Qed.	Instance	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	Binvalue_Idempotent
Binvalue_Associative i : Associative R (@Bin.value _ _ (e_bin i)). Proof. destruct ((e_bin i)); auto. Qed.	Instance	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	Binvalue_Associative
Binvalue_Proper i : Proper (R ==> R ==> R) (@Bin.value _ _ (e_bin i) ). Proof. destruct ((e_bin i)); auto. Qed. #[local] Hint Resolve Binvalue_Proper Binvalue_Associative Binvalue_Commutative : core. #[local] Hint Resolve is_unit_of_Unit : core. (** Auxiliary lemmas about sums *)	Instance	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	Binvalue_Proper
is_sum_spec_ind : T -> @discr (mset T) -> Prop := \| is_sum_spec_op : forall j l, j = i -> is_sum_spec_ind (sum j l) (Is_op l) \| is_sum_spec_unit : forall j, is_unit j = true -> is_sum_spec_ind (unit j) (Is_unit j) \| is_sum_spec_nothing : forall u, is_sum_spec_ind u (Is_nothing).	Inductive	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	is_sum_spec_ind
is_sum_spec u : is_sum_spec_ind u (is_sum i is_unit u). Proof. unfold is_sum; case u; intros; try constructor. case_eq (eq_idx_bool p i); intros; subst; try constructor; auto. revert H. case eq_idx_spec; try discriminate. auto. case_eq (is_unit p); intros; try constructor. auto. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	is_sum_spec
assoc : @Associative X R (Bin.value (e_bin i)). Proof. destruct (e_bin i). simpl. assumption. Qed.	Instance	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	assoc
proper : Proper (R ==> R ==> R)(Bin.value (e_bin i)). Proof. destruct (e_bin i). simpl. assumption. Qed. Hypothesis comm : @Commutative X R (Bin.value (e_bin i)).	Instance	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	proper
sum'_sum : forall (l: mset T), eval (sum' i l) == eval (sum i l). Proof. intros [[a n] \| [a n] l]; destruct n; simpl; reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	sum'_sum
eval_sum_nil x : eval (sum i (nil (x,xH))) == (eval x). Proof. rewrite <- sum'_sum. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval_sum_nil
eval_sum_cons : forall n a (l: mset T), (eval (sum i ((a,n)::l))) == (@Bin.value _ _ (e_bin i) (@copy _ (@Bin.value _ _ (e_bin i)) n (eval a)) (eval (sum i l))). Proof. intros n a [[? ? ]\|[b m] l]; simpl; reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval_sum_cons
compat_sum_unit : @m idx (mset T) -> Prop := \| csu_left : forall x, is_unit x = true-> compat_sum_unit (left x) \| csu_right : forall m, compat_sum_unit (right m).	Inductive	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	compat_sum_unit
compat_sum_unit_return x n : compat_sum_unit (return_sum i is_unit x n). Proof. unfold return_sum. case is_sum_spec; intros; try constructor; auto. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	compat_sum_unit_return
compat_sum_unit_add : forall x n h, compat_sum_unit h -> compat_sum_unit (add_to_sum i (is_unit_of i) x n h). Proof. unfold add_to_sum;intros; inversion H; case_eq (is_sum i (is_unit_of i) x); intros; simpl; try constructor \|\| eauto. apply H0. Qed. (* Hint Resolve copy_plus. : this lags because of the inference of the implicit arguments *) #[local] Hint Extern 5 (copy (?n + ?m) (eval ?a) == Bin.value (copy ?n (eval ?a)) (copy ?m (eval ?a))) => apply copy_plus : core. #[local] Hint Extern 5 (?x == ?x) => reflexivity : core. #[local] Hint Extern 5 ( Bin.value ?x ?y == Bin.value ?y ?x) => apply Bin.comm : core.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	compat_sum_unit_add
eval_merge_bin : forall (h k: mset T), eval (sum i (merge_msets compare h k)) == @Bin.value _ _ (e_bin i) (eval (sum i h)) (eval (sum i k)). Proof. induction h as [[a n]\|[a n] h IHh]; intro k. - simpl; induction k as [[b m]\|[b m] k IHk]; simpl. * destruct (tcompare_weak_spec a b) as [a\|a b\|a b]; simpl; auto. apply copy_plus; auto. * destruct (tcompare_weak_spec a b) as [a\|a b\|a b]; simpl; auto. rewrite copy_plus,law_assoc; auto. rewrite IHk; clear IHk. rewrite 2 law_assoc. apply proper; [apply law_comm\|reflexivity]. - induction k as [[b m]\|[b m] k IHk]; simpl; simpl in IHh. * destruct (tcompare_weak_spec a b) as [a\|a b\|a b]; simpl. rewrite (law_comm _ (copy m (eval a))). rewrite law_assoc, <- copy_plus, Pplus_comm; auto. rewrite <- law_assoc, IHh. reflexivity. rewrite law_comm. reflexivity. * simpl in IHk. destruct (tcompare_weak_spec a b) as [a\|a b\|a b]; simpl. rewrite IHh; clear IHh. rewrite 2 law_assoc. rewrite (law_comm _ (copy m (eval a))). rewrite law_assoc, <- copy_plus, Pplus_comm; auto. rewrite IHh; clear IHh. simpl. rewrite law_assoc. reflexivity. rewrite 2 (law_comm (copy m (eval b))). rewrite law_assoc. apply proper; [ \| reflexivity]. rewrite <- IHk. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval_merge_bin
copy_mset' n (l: mset T) : copy_mset n l = nelist_map (fun vm => let '(v,m):=vm in (v,Pmult n m)) l. Proof. unfold copy_mset. destruct n; try reflexivity. simpl. induction l as [\|[a l] IHl]; simpl; try congruence. destruct a; reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	copy_mset'
copy_mset_succ n (l: mset T) : eval (sum i (copy_mset (Pos.succ n) l)) == @Bin.value _ _ (e_bin i) (eval (sum i l)) (eval (sum i (copy_mset n l))). Proof. rewrite 2 copy_mset'. induction l as [[a m]\|[a m] l IHl]. simpl eval. rewrite <- copy_plus; auto. rewrite Pmult_Sn_m. reflexivity. simpl nelist_map. rewrite ! eval_sum_cons. rewrite IHl. clear IHl. rewrite Pmult_Sn_m. rewrite copy_plus; auto. rewrite <- !law_assoc. apply Binvalue_Proper; try reflexivity. rewrite law_comm . rewrite <- !law_assoc. apply proper; try reflexivity. apply law_comm. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	copy_mset_succ
copy_mset_copy : forall n (m : mset T), eval (sum i (copy_mset n m)) == @copy _ (@Bin.value _ _ (e_bin i)) n (eval (sum i m)). Proof. induction n using Pind; intros. - unfold copy_mset. rewrite copy_xH. reflexivity. - rewrite copy_mset_succ. rewrite copy_Psucc. rewrite IHn. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	copy_mset_copy
compat_sum_unit_Unit : forall p, compat_sum_unit (left p) -> @Unit X R (Bin.value (e_bin i)) (eval (unit p)). Proof. intros; inversion H; subst; auto. Qed.	Instance	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	compat_sum_unit_Unit
copy_n_unit : forall j n, is_unit j = true -> eval (unit j) == @copy _ (Bin.value (e_bin i)) n (eval (unit j)). Proof. intros; induction n using Prect. rewrite copy_xH. reflexivity. rewrite copy_Psucc. rewrite <- IHn. apply is_unit_sum_Unit in H. rewrite law_neutral_left. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	copy_n_unit
z0 l r (H : compat_sum_unit r) : eval (sum i (run_msets (comp (merge_msets compare) l r))) == eval (sum i ((merge_msets compare) (l) (run_msets r))). Proof. unfold comp. unfold run_msets. case_eq r; intros; subst; [\|reflexivity]. rewrite eval_merge_bin; auto. rewrite eval_sum_nil. apply compat_sum_unit_Unit in H. rewrite law_neutral_right. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	z0
z1 : forall n x, eval (sum i (run_msets (return_sum i (is_unit) x n ))) == @copy _ (@Bin.value _ _ (e_bin i)) n (eval x). Proof. intros; unfold return_sum, run_msets. case (is_sum_spec); intros; subst. - rewrite copy_mset_copy; reflexivity. - rewrite eval_sum_nil. apply copy_n_unit. auto. - reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	z1
z2 : forall u n x, compat_sum_unit x -> eval (sum i (run_msets (add_to_sum i (is_unit) u n x))) == @Bin.value _ _ (e_bin i) (@copy _ (@Bin.value _ _ (e_bin i)) n (eval u)) (eval (sum i (run_msets x))). Proof. intros u n x Hix. unfold add_to_sum. case is_sum_spec; intros; subst. - rewrite z0 by auto. rewrite eval_merge_bin, copy_mset_copy. reflexivity. - rewrite <- copy_n_unit by assumption. apply is_unit_sum_Unit in H. rewrite law_neutral_left. reflexivity. - rewrite z0 by auto. rewrite eval_merge_bin. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	z2
eval_norm_msets i norm (Comm : Commutative R (Bin.value (e_bin i))) (Hnorm: forall u, eval (norm u) == eval u) : forall h, eval (sum i (norm_msets norm i h)) == eval (sum i h). Proof. unfold norm_msets. assert (H : forall h : mset T, eval (sum i (run_msets (norm_msets_ i (is_unit_of i) norm h))) == eval (sum i h) /\ compat_sum_unit (is_unit_of i) (norm_msets_ i (is_unit_of i) norm h)). induction h as [[a n] \| [a n] h [IHh IHh']]; simpl norm_msets_; split. - rewrite z1 by auto. rewrite Hnorm. reflexivity. - apply compat_sum_unit_return. - rewrite z2 by auto. rewrite IHh, eval_sum_cons, Hnorm. reflexivity. - apply compat_sum_unit_add, IHh'. - apply H. Defined.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval_norm_msets
copy_idem i (Idem : Idempotent R (Bin.value (e_bin i))) n x : copy (plus:=(Bin.value (e_bin i))) n x == x. Proof. induction n using Pos.peano_ind; simpl. - apply copy_xH. - rewrite copy_Psucc, IHn; apply law_idem. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	copy_idem
eval_reduce_msets i (Idem : Idempotent R (Bin.value (e_bin i))) m : eval (sum i (reduce_mset m)) == eval (sum i m). Proof. induction m as [[a n]\|[a n] m IH]. - simpl. now rewrite 2copy_idem. - simpl. rewrite IH. now rewrite 2copy_idem. Qed. (** Auxiliary lemmas about products *)	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval_reduce_msets
is_prd_spec_ind : T -> @discr (nelist T) -> Prop := \| is_prd_spec_op : forall j l, j = i -> is_prd_spec_ind (prd j l) (Is_op l) \| is_prd_spec_unit : forall j, is_unit j = true -> is_prd_spec_ind (unit j) (Is_unit j) \| is_prd_spec_nothing : forall u, is_prd_spec_ind u (Is_nothing).	Inductive	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	is_prd_spec_ind
is_prd_spec u : is_prd_spec_ind u (is_prd i is_unit u). Proof. unfold is_prd; case u; intros; try constructor. case (eq_idx_spec); intros; subst; try constructor; auto. case_eq (is_unit p); intros; try constructor; auto. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	is_prd_spec
prd'_prd : forall (l: nelist T), eval (prd' i l) == eval (prd i l). Proof. intros [?\|? [\|? ?]]; simpl; reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	prd'_prd
eval_prd_nil x: eval (prd i (nil x)) == eval x. Proof. rewrite <- prd'_prd. simpl. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval_prd_nil
eval_prd_cons a : forall (l: nelist T), eval (prd i (a::l)) == @Bin.value _ _ (e_bin i) (eval a) (eval (prd i l)). Proof. intros [\|b l]; simpl; reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval_prd_cons
eval_prd_app : forall (h k: nelist T), eval (prd i (h++k)) == @Bin.value _ _ (e_bin i) (eval (prd i h)) (eval (prd i k)). Proof. induction h; intro k. simpl; try reflexivity. simpl appne. rewrite 2 eval_prd_cons, IHh, law_assoc. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval_prd_app
compat_prd_unit : @m idx (nelist T) -> Prop := \| cpu_left : forall x, is_unit x = true -> compat_prd_unit (left x) \| cpu_right : forall m, compat_prd_unit (right m).	Inductive	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	compat_prd_unit
compat_prd_unit_return x : compat_prd_unit (return_prd i is_unit x). Proof. unfold return_prd. case (is_prd_spec); intros; try constructor; auto. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	compat_prd_unit_return
compat_prd_unit_add : forall x h, compat_prd_unit h -> compat_prd_unit (add_to_prd i is_unit x h). Proof. intros; unfold add_to_prd, comp. case (is_prd_spec); intros; try constructor; auto. - unfold comp; case h; try constructor. - unfold comp; case h; try constructor. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	compat_prd_unit_add
compat_prd_Unit : forall p, compat_prd_unit (left p) -> @Unit X R (Bin.value (e_bin i)) (eval (unit p)). Proof. intros. inversion H; subst. apply is_unit_prd_Unit. assumption. Qed.	Instance	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	compat_prd_Unit
z0' : forall l (r: @m idx (nelist T)), compat_prd_unit r -> eval (prd i (run_list (comp (@appne T) l r))) == eval (prd i ((appne (l) (run_list r)))). Proof. intros. unfold comp. unfold run_list. case_eq r; intros; auto; subst. rewrite eval_prd_app. rewrite eval_prd_nil. apply compat_prd_Unit in H. rewrite law_neutral_right. reflexivity. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	z0'
z1' a : eval (prd i (run_list (return_prd i is_unit a))) == eval (prd i (nil a)). Proof. intros. unfold return_prd. unfold run_list. case (is_prd_spec); intros; subst; reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	z1'
z2' : forall u x, compat_prd_unit x -> eval (prd i (run_list (add_to_prd i is_unit u x))) == @Bin.value _ _ (e_bin i) (eval u) (eval (prd i (run_list x))). Proof. intros u x Hix. unfold add_to_prd. case (is_prd_spec); intros; subst. rewrite z0' by auto. rewrite eval_prd_app. reflexivity. apply is_unit_prd_Unit in H. rewrite law_neutral_left. reflexivity. rewrite z0' by auto. rewrite eval_prd_app. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	z2'
eval_norm_lists i (Hnorm: forall u, eval (norm u) == eval u) : forall h, eval (prd i (norm_lists norm i h)) == eval (prd i h). Proof. unfold norm_lists. assert (H : forall h : nelist T, eval (prd i (run_list (norm_lists_ i (is_unit_of i) norm h))) == eval (prd i h) /\ compat_prd_unit (is_unit_of i) (norm_lists_ i (is_unit_of i) norm h)). { induction h as [a \| a h [IHh IHh']]; simpl norm_lists_; split. rewrite z1'. simpl. apply Hnorm. apply compat_prd_unit_return. rewrite z2'. rewrite IHh. rewrite eval_prd_cons. rewrite Hnorm. reflexivity. apply is_unit_of_Unit. auto. apply compat_prd_unit_add. auto. } apply H. Defined. (** Correctness of the normalisation function *)	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval_norm_lists
eval_norm u: eval (norm u) == eval u with eval_norm_aux i l : forall (f: Sym.type_of i), Proper (@Sym.rel_of X R i) f -> eval_aux (vnorm l) f == eval_aux l f. Proof. induction u as [ p m \| p l \| ? \| ?]; simpl norm. - case_eq (is_commutative p); intros. case_eq (is_idempotent p); intros. rewrite sum'_sum. rewrite eval_reduce_msets. 2: eauto with typeclass_instances. apply eval_norm_msets; auto. rewrite sum'_sum. apply eval_norm_msets; auto. reflexivity. - rewrite prd'_prd. apply eval_norm_lists; auto. - apply eval_norm_aux, Sym.morph. - reflexivity. - induction l; simpl; intros f Hf. reflexivity. rewrite eval_norm. apply IHl, Hf; reflexivity. Qed. (** Corollaries, for goal normalisation or decision *)	Fixpoint	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	eval_norm
normalise : forall (u v: T), eval (norm u) == eval (norm v) -> eval u == eval v. Proof. intros u v. rewrite 2 eval_norm. trivial. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	normalise
compare_reflect_eq : forall u v, compare u v = Eq -> eval u == eval v. Proof. intros u v. case (tcompare_weak_spec u v); intros; try congruence. reflexivity. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	compare_reflect_eq
decide : forall (u v: T), compare (norm u) (norm v) = Eq -> eval u == eval v. Proof. intros u v H. apply normalise. apply compare_reflect_eq. apply H. Qed. Register decide as aac_tactics.internal.decide.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	decide
lift_normalise {S} {H : AAC_lift S R} : forall (u v: T), (let x := norm u in let y := norm v in S (eval x) (eval y)) -> S (eval u) (eval v). Proof. destruct H. intros u v; simpl; rewrite 2 eval_norm. trivial. Qed. Register lift_normalise as aac_tactics.internal.lift_normalise.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	lift_normalise
lift_transitivity_left (y x z : X): E x y -> R y z -> R x z. Proof. destruct H as [Hequiv Hproper]; intros G;rewrite G. trivial. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	lift_transitivity_left
lift_transitivity_right (y x z : X): E y z -> R x y -> R x z. Proof. destruct H as [Hequiv Hproper]; intros G. rewrite G. trivial. Qed.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	lift_transitivity_right
lift_reflexivity {HR :Reflexive R}: forall x y, E x y -> R x y. Proof. destruct H. intros ? ? G. rewrite G. reflexivity. Qed. Register lift_transitivity_left as aac_tactics.internal.lift_transitivity_left. Register lift_transitivity_right as aac_tactics.internal.lift_transitivity_right. Register lift_reflexivity as aac_tactics.internal.lift_reflexivity.	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	lift_reflexivity
transitivity4 {A R} {H: @Equivalence A R} a b a' b': R a a' -> R b b' -> R a b -> R a' b'. Proof. now intros -> ->. Qed. Tactic Notation "aac_normalise" "in" hyp(H) := eapply transitivity4 in H; [\| aac_normalise; reflexivity \| aac_normalise; reflexivity].	Lemma	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	transitivity4
aac_normalise_all := aac_normalise; repeat match goal with \| H: _ \|- _ => aac_normalise in H end. Tactic Notation "aac_normalise" "in" "*" := aac_normalise_all.	Ltac	theories	[ "From Stdlib Require Import Arith NArith List.", "From Stdlib Require Import FMapPositive Relations RelationClasses.", "From Stdlib Require Export Morphisms.", "From AAC_tactics Require Import Utils Constants." ]	theories/AAC.v	aac_normalise_all

sigma := PositiveMap.t.

Definition

theories