natpair_integers.v

Require Import HoTT.HIT.quotient
  HoTT.Universes.TruncType.[Loading ML file number_string_notation_plugin.cmxs (using legacy method) ... done]
Require Import
  HoTT.Classes.implementations.peano_naturals
  HoTT.Classes.interfaces.abstract_algebra
  HoTT.Classes.interfaces.orders
  HoTT.Classes.interfaces.integers
  HoTT.Classes.theory.rings
  HoTT.Classes.theory.groups
  HoTT.Classes.theory.apartness
  HoTT.Classes.orders.sum
  HoTT.Classes.orders.rings
  HoTT.Classes.tactics.ring_tac
  HoTT.Classes.theory.naturals.

Generalizable Variables B.

Import ring_quote.Quoting.Instances.
Local Set Universe Minimization ToSet.

Module NatPair.

Module Import PairT.

Record T (N : Type) := C { pos : N ; neg : N }.
Arguments C {N} _ _.
Arguments pos {N} _.
Arguments neg {N} _.

Section contents.
Universe UN UNalt.
Context (N : Type@{UN}) `{Naturals@{UN UN UN UN UN UN UN UNalt} N}.

#[export] Instance T_set : IsHSet (T N).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
IsHSet (T N)
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
IsHSet (T N)
assert (E : sig (fun _ : N => N) <~> (T N)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
{_ : N & N} <~> T N
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
E: {_ : N & N} <~> T N
IsHSet (T N)
-N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
{_ : N & N} <~> T N issig.
-N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
E: {_ : N & N} <~> T N
IsHSet (T N) exact (istrunc_equiv_istrunc _ E).
Qed.

#[export] Instance inject : Cast N (T N) := fun x => C x 0.

Definition equiv := fun x y => pos x + neg y = pos y + neg x.

#[export] Instance equiv_is_equiv_rel@{} : EquivRel equiv.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
EquivRel equiv
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
EquivRel equiv
split.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
Reflexive equiv
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
Symmetric equiv
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
Transitive equiv
-N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
Reflexive equiv hnf.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall x : T N, equiv x x reflexivity.
-N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
Symmetric equiv hnf.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall x y : T N, equiv x y -> equiv y x unfold equiv.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall x y : T N,
pos x + neg y = pos y + neg x ->
pos y + neg x = pos x + neg y
  intros ??;apply symmetry.
-N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
Transitive equiv hnf.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall x y z : T N,
equiv x y -> equiv y z -> equiv x z unfold equiv.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall x y z : T N,
pos x + neg y = pos y + neg x ->
pos y + neg z = pos z + neg y ->
pos x + neg z = pos z + neg x
  intros a b c E1 E2.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
pos a + neg c = pos c + neg a
  apply (left_cancellation (+) (neg b)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
neg b + (pos a + neg c) = neg b + (pos c + neg a)
  rewrite (plus_assoc (neg b) (pos a)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
neg b + pos a + neg c = neg b + (pos c + neg a)
  rewrite (plus_comm (neg b) (pos a)), E1.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
pos b + neg a + neg c = neg b + (pos c + neg a)
  rewrite (plus_comm (pos b)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
neg a + pos b + neg c = neg b + (pos c + neg a) rewrite <-plus_assoc.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
neg a + (pos b + neg c) = neg b + (pos c + neg a)
  rewrite E2.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
neg a + (pos c + neg b) = neg b + (pos c + neg a) rewrite (plus_comm (pos c) (neg b)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
neg a + (neg b + pos c) = neg b + (pos c + neg a)
  rewrite plus_assoc.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
neg a + neg b + pos c = neg b + (pos c + neg a) rewrite (plus_comm (neg a)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
neg b + neg a + pos c = neg b + (pos c + neg a)
  rewrite <-plus_assoc.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
neg b + (neg a + pos c) = neg b + (pos c + neg a) rewrite (plus_comm (neg a)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
a, b, c: T N
E1: pos a + neg b = pos b + neg a
E2: pos b + neg c = pos c + neg b
neg b + (pos c + neg a) = neg b + (pos c + neg a)
  reflexivity.
Qed.

Instance pl : Plus (T N) := fun x y => C (pos x + pos y) (neg x + neg y).

Instance ml : Mult (T N) := fun x y =>
  C (pos x * pos y + neg x * neg y) (pos x * neg y + neg x * pos y).

Instance opp : Negate (T N) := fun x => C (neg x) (pos x).

Instance SR0 : Zero (T N) := C 0 0.

Instance SR1 : One (T N) := C 1 0.

Lemma pl_respects : forall q1 q2, equiv q1 q2 -> forall r1 r2, equiv r1 r2 ->
  equiv (q1 + r1) (q2 + r2).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> equiv (q1 + r1) (q2 + r2)
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> equiv (q1 + r1) (q2 + r2)
unfold equiv;simpl.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
pos q1 + neg q2 = pos q2 + neg q1 ->
forall r1 r2 : T N,
pos r1 + neg r2 = pos r2 + neg r1 ->
pos q1 + pos r1 + (neg q2 + neg r2) =
pos q2 + pos r2 + (neg q1 + neg r1)
intros q1 q2 Eq r1 r2 Er.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 + pos r1 + (neg q2 + neg r2) =
pos q2 + pos r2 + (neg q1 + neg r1)
rewrite (plus_assoc _ (neg q2)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 + pos r1 + neg q2 + neg r2 =
pos q2 + pos r2 + (neg q1 + neg r1)
rewrite <-(plus_assoc (pos q1)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 + (pos r1 + neg q2) + neg r2 =
pos q2 + pos r2 + (neg q1 + neg r1)
rewrite (plus_comm (pos r1)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 + (neg q2 + pos r1) + neg r2 =
pos q2 + pos r2 + (neg q1 + neg r1)
rewrite (plus_assoc (pos q1)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 + neg q2 + pos r1 + neg r2 =
pos q2 + pos r2 + (neg q1 + neg r1) rewrite Eq.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q2 + neg q1 + pos r1 + neg r2 =
pos q2 + pos r2 + (neg q1 + neg r1)
rewrite <-(plus_assoc _ (pos r1)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q2 + neg q1 + (pos r1 + neg r2) =
pos q2 + pos r2 + (neg q1 + neg r1) rewrite Er.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q2 + neg q1 + (pos r2 + neg r1) =
pos q2 + pos r2 + (neg q1 + neg r1)
rewrite plus_assoc.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q2 + neg q1 + pos r2 + neg r1 =
pos q2 + pos r2 + (neg q1 + neg r1) rewrite <-(plus_assoc (pos q2)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q2 + (neg q1 + pos r2) + neg r1 =
pos q2 + pos r2 + (neg q1 + neg r1)
rewrite (plus_comm (neg q1)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q2 + (pos r2 + neg q1) + neg r1 =
pos q2 + pos r2 + (neg q1 + neg r1) rewrite !plus_assoc.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q2 + pos r2 + neg q1 + neg r1 =
pos q2 + pos r2 + neg q1 + neg r1
reflexivity.
Qed.

Lemma ml_respects : forall q1 q2, equiv q1 q2 -> forall r1 r2, equiv r1 r2 ->
  equiv (q1 * r1) (q2 * r2).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> equiv (q1 * r1) (q2 * r2)
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> equiv (q1 * r1) (q2 * r2)
intros q1 q2 Eq r1 r2 Er.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: equiv q1 q2
r1, r2: T N
Er: equiv r1 r2
equiv (q1 * r1) (q2 * r2) transitivity (q1 * r2);unfold equiv in *;simpl.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r1 + neg q1 * neg r1 +
(pos q1 * neg r2 + neg q1 * pos r2) =
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q1 * neg r1 + neg q1 * pos r1)
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q2 * neg r2 + neg q2 * pos r2) =
pos q2 * pos r2 + neg q2 * neg r2 +
(pos q1 * neg r2 + neg q1 * pos r2)
-N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r1 + neg q1 * neg r1 +
(pos q1 * neg r2 + neg q1 * pos r2) =
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q1 * neg r1 + neg q1 * pos r1) transitivity (pos q1 * (pos r1 + neg r2) + neg q1 * (neg r1 + pos r2)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r1 + neg q1 * neg r1 +
(pos q1 * neg r2 + neg q1 * pos r2) =
pos q1 * (pos r1 + neg r2) +
neg q1 * (neg r1 + pos r2)
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * (pos r1 + neg r2) +
neg q1 * (neg r1 + pos r2) =
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q1 * neg r1 + neg q1 * pos r1)
  +N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r1 + neg q1 * neg r1 +
(pos q1 * neg r2 + neg q1 * pos r2) =
pos q1 * (pos r1 + neg r2) +
neg q1 * (neg r1 + pos r2) rewrite 2!plus_mult_distr_l.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r1 + neg q1 * neg r1 +
(pos q1 * neg r2 + neg q1 * pos r2) =
pos q1 * pos r1 + pos q1 * neg r2 +
(neg q1 * neg r1 + neg q1 * pos r2)
    rewrite <-2!plus_assoc.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r1 +
(neg q1 * neg r1 + (pos q1 * neg r2 + neg q1 * pos r2)) =
pos q1 * pos r1 +
(pos q1 * neg r2 + (neg q1 * neg r1 + neg q1 * pos r2))
    apply ap.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
neg q1 * neg r1 + (pos q1 * neg r2 + neg q1 * pos r2) =
pos q1 * neg r2 + (neg q1 * neg r1 + neg q1 * pos r2)
    rewrite 2!plus_assoc.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
neg q1 * neg r1 + pos q1 * neg r2 + neg q1 * pos r2 =
pos q1 * neg r2 + neg q1 * neg r1 + neg q1 * pos r2 rewrite (plus_comm (neg q1 * neg r1)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * neg r2 + neg q1 * neg r1 + neg q1 * pos r2 =
pos q1 * neg r2 + neg q1 * neg r1 + neg q1 * pos r2
    reflexivity.
  +N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * (pos r1 + neg r2) +
neg q1 * (neg r1 + pos r2) =
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q1 * neg r1 + neg q1 * pos r1) rewrite Er.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * (pos r2 + neg r1) +
neg q1 * (neg r1 + pos r2) =
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q1 * neg r1 + neg q1 * pos r1) rewrite plus_mult_distr_l.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r2 + pos q1 * neg r1 +
neg q1 * (neg r1 + pos r2) =
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q1 * neg r1 + neg q1 * pos r1)
    rewrite (plus_comm (neg r1)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r2 + pos q1 * neg r1 +
neg q1 * (pos r2 + neg r1) =
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q1 * neg r1 + neg q1 * pos r1)
    rewrite <-Er.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r2 + pos q1 * neg r1 +
neg q1 * (pos r1 + neg r2) =
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q1 * neg r1 + neg q1 * pos r1) rewrite plus_mult_distr_l.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r2 + pos q1 * neg r1 +
(neg q1 * pos r1 + neg q1 * neg r2) =
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q1 * neg r1 + neg q1 * pos r1)
    rewrite <-2!plus_assoc.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r2 +
(pos q1 * neg r1 + (neg q1 * pos r1 + neg q1 * neg r2)) =
pos q1 * pos r2 +
(neg q1 * neg r2 + (pos q1 * neg r1 + neg q1 * pos r1)) apply ap.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * neg r1 + (neg q1 * pos r1 + neg q1 * neg r2) =
neg q1 * neg r2 + (pos q1 * neg r1 + neg q1 * pos r1)
    rewrite (plus_comm (neg q1 * pos r1)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * neg r1 + (neg q1 * neg r2 + neg q1 * pos r1) =
neg q1 * neg r2 + (pos q1 * neg r1 + neg q1 * pos r1)
    rewrite 2!plus_assoc.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * neg r1 + neg q1 * neg r2 + neg q1 * pos r1 =
neg q1 * neg r2 + pos q1 * neg r1 + neg q1 * pos r1
    rewrite (plus_comm (pos q1 * neg r1)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
neg q1 * neg r2 + pos q1 * neg r1 + neg q1 * pos r1 =
neg q1 * neg r2 + pos q1 * neg r1 + neg q1 * pos r1 reflexivity.
-N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q2 * neg r2 + neg q2 * pos r2) =
pos q2 * pos r2 + neg q2 * neg r2 +
(pos q1 * neg r2 + neg q1 * pos r2) transitivity ((pos q1 + neg q2) * pos r2 + (neg q1 + pos q2) * neg r2).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q2 * neg r2 + neg q2 * pos r2) =
(pos q1 + neg q2) * pos r2 +
(neg q1 + pos q2) * neg r2
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
(pos q1 + neg q2) * pos r2 +
(neg q1 + pos q2) * neg r2 =
pos q2 * pos r2 + neg q2 * neg r2 +
(pos q1 * neg r2 + neg q1 * pos r2)
  +N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q2 * neg r2 + neg q2 * pos r2) =
(pos q1 + neg q2) * pos r2 +
(neg q1 + pos q2) * neg r2 rewrite 2!plus_mult_distr_r.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * pos r2 + neg q1 * neg r2 +
(pos q2 * neg r2 + neg q2 * pos r2) =
pos q1 * pos r2 + neg q2 * pos r2 +
(neg q1 * neg r2 + pos q2 * neg r2)
    rewrite <-2!plus_assoc;apply ap.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
neg q1 * neg r2 + (pos q2 * neg r2 + neg q2 * pos r2) =
neg q2 * pos r2 + (neg q1 * neg r2 + pos q2 * neg r2)
    rewrite (plus_comm (pos q2 * neg r2)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
neg q1 * neg r2 + (neg q2 * pos r2 + pos q2 * neg r2) =
neg q2 * pos r2 + (neg q1 * neg r2 + pos q2 * neg r2)
    rewrite 2!plus_assoc.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
neg q1 * neg r2 + neg q2 * pos r2 + pos q2 * neg r2 =
neg q2 * pos r2 + neg q1 * neg r2 + pos q2 * neg r2 rewrite (plus_comm (neg q1 * neg r2)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
neg q2 * pos r2 + neg q1 * neg r2 + pos q2 * neg r2 =
neg q2 * pos r2 + neg q1 * neg r2 + pos q2 * neg r2
    reflexivity.
  +N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
(pos q1 + neg q2) * pos r2 +
(neg q1 + pos q2) * neg r2 =
pos q2 * pos r2 + neg q2 * neg r2 +
(pos q1 * neg r2 + neg q1 * pos r2) rewrite Eq,plus_mult_distr_r.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q2 * pos r2 + neg q1 * pos r2 +
(neg q1 + pos q2) * neg r2 =
pos q2 * pos r2 + neg q2 * neg r2 +
(pos q1 * neg r2 + neg q1 * pos r2)
    rewrite (plus_comm (neg q1)),<-Eq,plus_mult_distr_r.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q2 * pos r2 + neg q1 * pos r2 +
(pos q1 * neg r2 + neg q2 * neg r2) =
pos q2 * pos r2 + neg q2 * neg r2 +
(pos q1 * neg r2 + neg q1 * pos r2)
    rewrite <-2!plus_assoc.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q2 * pos r2 +
(neg q1 * pos r2 + (pos q1 * neg r2 + neg q2 * neg r2)) =
pos q2 * pos r2 +
(neg q2 * neg r2 + (pos q1 * neg r2 + neg q1 * pos r2)) apply ap.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
neg q1 * pos r2 + (pos q1 * neg r2 + neg q2 * neg r2) =
neg q2 * neg r2 + (pos q1 * neg r2 + neg q1 * pos r2)
    rewrite plus_assoc,(plus_comm (neg q1 * pos r2)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r1, r2: T N
Er: pos r1 + neg r2 = pos r2 + neg r1
pos q1 * neg r2 + neg q1 * pos r2 + neg q2 * neg r2 =
neg q2 * neg r2 + (pos q1 * neg r2 + neg q1 * pos r2)
    apply plus_comm.
Qed.

Lemma opp_respects : forall q1 q2, equiv q1 q2 -> equiv (opp q1) (opp q2).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 -> equiv (opp q1) (opp q2)
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 -> equiv (opp q1) (opp q2)
unfold equiv;simpl.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
pos q1 + neg q2 = pos q2 + neg q1 ->
neg q1 + pos q2 = neg q2 + pos q1
intros q1 q2 E.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
E: pos q1 + neg q2 = pos q2 + neg q1
neg q1 + pos q2 = neg q2 + pos q1
rewrite !(plus_comm (neg _)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
E: pos q1 + neg q2 = pos q2 + neg q1
pos q2 + neg q1 = pos q1 + neg q2 symmetry.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
E: pos q1 + neg q2 = pos q2 + neg q1
pos q1 + neg q2 = pos q2 + neg q1 apply E.
Qed.

Definition Tle : Le (T N)
  := fun a b => pos a + neg b <= pos b + neg a.
Definition Tlt : Lt (T N)
  := fun a b => pos a + neg b < pos b + neg a.
Definition Tapart : Apart (T N)
  := fun a b => apart (pos a + neg b) (pos b + neg a).

#[export] Instance Tle_hprop@{}
  : is_mere_relation (T N) Tle.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
is_mere_relation (T N) Tle
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
is_mere_relation (T N) Tle
intros;unfold Tle.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
x, y: T N
IsHProp (pos x + neg y ≤ pos y + neg x)
apply full_pseudo_srorder_le_hprop.
Qed.

#[export] Instance Tlt_hprop@{}
  : is_mere_relation (T N) Tlt.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
is_mere_relation (T N) Tlt
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
is_mere_relation (T N) Tlt
intros;unfold Tlt;exact _.
Qed.

Local Existing Instance pseudo_order_apart.
#[export] Instance Tapart_hprop@{} : is_mere_relation (T N) Tapart.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
is_mere_relation (T N) Tapart
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
is_mere_relation (T N) Tapart
intros;unfold Tapart;exact _.
Qed.

Lemma le_respects_aux@{} : forall q1 q2, equiv q1 q2 ->
  forall r1 r2, equiv r1 r2 ->
  Tle q1 r1 -> Tle q2 r2.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tle q1 r1 -> Tle q2 r2
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tle q1 r1 -> Tle q2 r2
unfold equiv,Tle;intros [pa na] [pb nb] Eq [pc nc] [pd nd] Er E;simpl in *.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc ≤ pc + na
pb + nd ≤ pd + nb
apply (order_reflecting (+ (pc + na))).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc ≤ pc + na
pb + nd + (pc + na) ≤ pd + nb + (pc + na)
assert (Erw : pb + nd + (pc + na)
  = (pb + na) + (pc + nd)) by ring_with_nat.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc ≤ pc + na
Erw: pb + nd + (pc + na) = pb + na + (pc + nd)
pb + nd + (pc + na) ≤ pd + nb + (pc + na)
rewrite Erw,<-Eq,Er;clear Erw.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc ≤ pc + na
pa + nb + (pd + nc) ≤ pd + nb + (pc + na)
assert (Erw : pa + nb + (pd + nc) = pd + nb + (pa + nc)) by ring_with_nat.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc ≤ pc + na
Erw: pa + nb + (pd + nc) = pd + nb + (pa + nc)
pa + nb + (pd + nc) ≤ pd + nb + (pc + na)
rewrite Erw.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc ≤ pc + na
Erw: pa + nb + (pd + nc) = pd + nb + (pa + nc)
pd + nb + (pa + nc) ≤ pd + nb + (pc + na)
apply (order_preserving _), E.
Qed.

Lemma le_respects@{} : forall q1 q2, equiv q1 q2 -> forall r1 r2, equiv r1 r2 ->
  Tle q1 r1 <~> Tle q2 r2.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tle q1 r1 <~> Tle q2 r2
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tle q1 r1 <~> Tle q2 r2
intros.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
X: equiv q1 q2
r1, r2: T N
X0: equiv r1 r2
Tle q1 r1 <~> Tle q2 r2 apply equiv_iff_hprop_uncurried.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
X: equiv q1 q2
r1, r2: T N
X0: equiv r1 r2
Tle q1 r1 <-> Tle q2 r2
split;apply le_respects_aux;
trivial;apply symmetry;trivial.
Qed.

Lemma lt_respects_aux@{} : forall q1 q2, equiv q1 q2 -> forall r1 r2, equiv r1 r2 ->
  Tlt q1 r1 -> Tlt q2 r2.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tlt q1 r1 -> Tlt q2 r2
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tlt q1 r1 -> Tlt q2 r2
unfold equiv,Tlt;intros [pa na] [pb nb] Eq [pc nc] [pd nd] Er E;simpl in *.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc < pc + na
pb + nd < pd + nb
apply (strictly_order_reflecting (+ (pc + na))).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc < pc + na
pb + nd + (pc + na) < pd + nb + (pc + na)
assert (Erw : pb + nd + (pc + na)
  = (pb + na) + (pc + nd)) by ring_with_nat.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc < pc + na
Erw: pb + nd + (pc + na) = pb + na + (pc + nd)
pb + nd + (pc + na) < pd + nb + (pc + na)
rewrite Erw,<-Eq,Er;clear Erw.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc < pc + na
pa + nb + (pd + nc) < pd + nb + (pc + na)
assert (Erw : pa + nb + (pd + nc) = pd + nb + (pa + nc)) by ring_with_nat.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc < pc + na
Erw: pa + nb + (pd + nc) = pd + nb + (pa + nc)
pa + nb + (pd + nc) < pd + nb + (pc + na)
rewrite Erw.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
pa, na, pb, nb: N
Eq: pa + nb = pb + na
pc, nc, pd, nd: N
Er: pc + nd = pd + nc
E: pa + nc < pc + na
Erw: pa + nb + (pd + nc) = pd + nb + (pa + nc)
pd + nb + (pa + nc) < pd + nb + (pc + na)
apply (strictly_order_preserving _), E.
Qed.

Lemma lt_respects@{} : forall q1 q2, equiv q1 q2 -> forall r1 r2, equiv r1 r2 ->
  Tlt q1 r1 <~> Tlt q2 r2.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tlt q1 r1 <~> Tlt q2 r2
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tlt q1 r1 <~> Tlt q2 r2
intros.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
X: equiv q1 q2
r1, r2: T N
X0: equiv r1 r2
Tlt q1 r1 <~> Tlt q2 r2 apply equiv_iff_hprop_uncurried.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
X: equiv q1 q2
r1, r2: T N
X0: equiv r1 r2
Tlt q1 r1 <-> Tlt q2 r2
split;apply lt_respects_aux;
trivial;apply symmetry;trivial.
Qed.

Lemma apart_cotrans@{} : CoTransitive Tapart.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
CoTransitive Tapart
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
CoTransitive Tapart
hnf.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall x y : T N,
Tapart x y ->
forall z : T N, hor (Tapart x z) (Tapart z y)
unfold Tapart.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall x y : T N,
pos x + neg y ≶ pos y + neg x ->
forall z : T N,
hor (pos x + neg z ≶ pos z + neg x)
  (pos z + neg y ≶ pos y + neg z) intros q1 q2 Eq r.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 ≶ pos q2 + neg q1
r: T N
hor (pos q1 + neg r ≶ pos r + neg q1)
  (pos r + neg q2 ≶ pos q2 + neg r)
apply (strong_left_cancellation (+) (neg r)) in Eq.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
hor (pos q1 + neg r ≶ pos r + neg q1)
  (pos r + neg q2 ≶ pos q2 + neg r)
apply (merely_destruct (cotransitive Eq (pos r + neg q1 + neg q2)));
intros [E|E];apply tr.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: neg r + (pos q1 + neg q2)
≶ pos r + neg q1 + neg q2
((plus (pos q1) (neg r) ≶ plus (pos r) (neg q1)) +
 (plus (pos r) (neg q2) ≶ plus (pos q2) (neg r)))%type
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: pos r + neg q1 + neg q2
≶ neg r + (pos q2 + neg q1)
((plus (pos q1) (neg r) ≶ plus (pos r) (neg q1)) +
 (plus (pos r) (neg q2) ≶ plus (pos q2) (neg r)))%type
-N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: neg r + (pos q1 + neg q2)
≶ pos r + neg q1 + neg q2
((plus (pos q1) (neg r) ≶ plus (pos r) (neg q1)) +
 (plus (pos r) (neg q2) ≶ plus (pos q2) (neg r)))%type left.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: neg r + (pos q1 + neg q2)
≶ pos r + neg q1 + neg q2
pos q1 + neg r ≶ pos r + neg q1 apply (strong_extensionality (+ (neg q2))).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: neg r + (pos q1 + neg q2)
≶ pos r + neg q1 + neg q2
pos q1 + neg r + neg q2 ≶ pos r + neg q1 + neg q2
  assert (Hrw : pos q1 + neg r + neg q2
    = neg r + (pos q1 + neg q2)) by ring_with_nat.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: neg r + (pos q1 + neg q2)
≶ pos r + neg q1 + neg q2
Hrw: pos q1 + neg r + neg q2 =
neg r + (pos q1 + neg q2)
pos q1 + neg r + neg q2 ≶ pos r + neg q1 + neg q2
  rewrite Hrw;clear Hrw.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: neg r + (pos q1 + neg q2)
≶ pos r + neg q1 + neg q2
neg r + (pos q1 + neg q2) ≶ pos r + neg q1 + neg q2
  trivial.
-N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: pos r + neg q1 + neg q2
≶ neg r + (pos q2 + neg q1)
((plus (pos q1) (neg r) ≶ plus (pos r) (neg q1)) +
 (plus (pos r) (neg q2) ≶ plus (pos q2) (neg r)))%type right.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: pos r + neg q1 + neg q2
≶ neg r + (pos q2 + neg q1)
pos r + neg q2 ≶ pos q2 + neg r apply (strong_extensionality (+ (neg q1))).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: pos r + neg q1 + neg q2
≶ neg r + (pos q2 + neg q1)
pos r + neg q2 + neg q1 ≶ pos q2 + neg r + neg q1
  assert (Hrw : pos r + neg q2 + neg q1 = pos r + neg q1 + neg q2)
  by ring_with_nat.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: pos r + neg q1 + neg q2
≶ neg r + (pos q2 + neg q1)
Hrw: pos r + neg q2 + neg q1 =
pos r + neg q1 + neg q2
pos r + neg q2 + neg q1 ≶ pos q2 + neg r + neg q1
  rewrite Hrw;clear Hrw.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: pos r + neg q1 + neg q2
≶ neg r + (pos q2 + neg q1)
pos r + neg q1 + neg q2 ≶ pos q2 + neg r + neg q1
  assert (Hrw : pos q2 + neg r + neg q1 = neg r + (pos q2 + neg q1))
  by ring_with_nat.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: pos r + neg q1 + neg q2
≶ neg r + (pos q2 + neg q1)
Hrw: pos q2 + neg r + neg q1 =
neg r + (pos q2 + neg q1)
pos r + neg q1 + neg q2 ≶ pos q2 + neg r + neg q1
  rewrite Hrw;clear Hrw.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2, r: T N
Eq: neg r + (pos q1 + neg q2)
≶ neg r + (pos q2 + neg q1)
E: pos r + neg q1 + neg q2
≶ neg r + (pos q2 + neg q1)
pos r + neg q1 + neg q2 ≶ neg r + (pos q2 + neg q1)
  trivial.
Qed.
Existing Instance apart_cotrans.

Instance : Symmetric Tapart.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
Symmetric Tapart
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
Symmetric Tapart
hnf.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall x y : T N, Tapart x y -> Tapart y x
unfold Tapart.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall x y : T N,
pos x + neg y ≶ pos y + neg x ->
pos y + neg x ≶ pos x + neg y
intros ??;apply symmetry.
Qed.

Lemma apart_respects_aux@{}
  : forall q1 q2, equiv q1 q2 -> forall r1 r2, equiv r1 r2 ->
  Tapart q1 r1 -> Tapart q2 r2.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tapart q1 r1 -> Tapart q2 r2
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tapart q1 r1 -> Tapart q2 r2
assert (forall q1 q2, equiv q1 q2 -> forall r, Tapart q1 r -> Tapart q2 r)
  as E.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r : T N, Tapart q1 r -> Tapart q2 r
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
E: forall q1 q2 : T N,
equiv q1 q2 ->
forall r : T N, Tapart q1 r -> Tapart q2 r
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tapart q1 r1 -> Tapart q2 r2
-N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r : T N, Tapart q1 r -> Tapart q2 r intros q1 q2 Eq r Er.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: equiv q1 q2
r: T N
Er: Tapart q1 r
Tapart q2 r
  unfold Tapart,equiv in *.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r: T N
Er: pos q1 + neg r ≶ pos r + neg q1
pos q2 + neg r ≶ pos r + neg q2
  apply (strong_extensionality (+ (neg q1))).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r: T N
Er: pos q1 + neg r ≶ pos r + neg q1
pos q2 + neg r + neg q1 ≶ pos r + neg q2 + neg q1
  assert (Hrw : pos q2 + neg r + neg q1 = (pos q2 + neg q1) + neg r)
  by ring_with_nat.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r: T N
Er: pos q1 + neg r ≶ pos r + neg q1
Hrw: pos q2 + neg r + neg q1 =
pos q2 + neg q1 + neg r
pos q2 + neg r + neg q1 ≶ pos r + neg q2 + neg q1
  rewrite Hrw;clear Hrw.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r: T N
Er: pos q1 + neg r ≶ pos r + neg q1
pos q2 + neg q1 + neg r ≶ pos r + neg q2 + neg q1
  rewrite <-Eq.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r: T N
Er: pos q1 + neg r ≶ pos r + neg q1
pos q1 + neg q2 + neg r ≶ pos r + neg q2 + neg q1
  assert (Hrw : pos q1 + neg q2 + neg r = neg q2 + (pos q1 + neg r))
  by ring_with_nat.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r: T N
Er: pos q1 + neg r ≶ pos r + neg q1
Hrw: pos q1 + neg q2 + neg r =
neg q2 + (pos q1 + neg r)
pos q1 + neg q2 + neg r ≶ pos r + neg q2 + neg q1
  rewrite Hrw;clear Hrw.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r: T N
Er: pos q1 + neg r ≶ pos r + neg q1
neg q2 + (pos q1 + neg r) ≶ pos r + neg q2 + neg q1
  assert (Hrw : pos r + neg q2 + neg q1 = neg q2 + (pos r + neg q1))
  by ring_with_nat;rewrite Hrw;clear Hrw.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: pos q1 + neg q2 = pos q2 + neg q1
r: T N
Er: pos q1 + neg r ≶ pos r + neg q1
neg q2 + (pos q1 + neg r) ≶ neg q2 + (pos r + neg q1)
  apply (strong_left_cancellation _ _),Er.
-N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
E: forall q1 q2 : T N,
equiv q1 q2 ->
forall r : T N, Tapart q1 r -> Tapart q2 r
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tapart q1 r1 -> Tapart q2 r2 intros ?? Eq ?? Er E'.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
E: forall q1 q2 : T N,
equiv q1 q2 ->
forall r : T N, Tapart q1 r -> Tapart q2 r
q1, q2: T N
Eq: equiv q1 q2
r1, r2: T N
Er: equiv r1 r2
E': Tapart q1 r1
Tapart q2 r2
  apply E with q1;trivial.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
E: forall q1 q2 : T N,
equiv q1 q2 ->
forall r : T N, Tapart q1 r -> Tapart q2 r
q1, q2: T N
Eq: equiv q1 q2
r1, r2: T N
Er: equiv r1 r2
E': Tapart q1 r1
Tapart q1 r2
  apply symmetry;apply E with r1;apply symmetry;trivial.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
E: forall q1 q2 : T N,
equiv q1 q2 ->
forall r : T N, Tapart q1 r -> Tapart q2 r
q1, q2: T N
Eq: equiv q1 q2
r1, r2: T N
Er: equiv r1 r2
E': Tapart q1 r1
equiv r2 r1
  apply symmetry;trivial.
Qed.

Lemma apart_respects : forall q1 q2, equiv q1 q2 -> forall r1 r2, equiv r1 r2 ->
  Tapart q1 r1 <~> Tapart q2 r2.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tapart q1 r1 <~> Tapart q2 r2
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
forall q1 q2 : T N,
equiv q1 q2 ->
forall r1 r2 : T N,
equiv r1 r2 -> Tapart q1 r1 <~> Tapart q2 r2
intros ?? Eq ?? Er.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: equiv q1 q2
r1, r2: T N
Er: equiv r1 r2
Tapart q1 r1 <~> Tapart q2 r2
apply equiv_iff_hprop_uncurried.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
q1, q2: T N
Eq: equiv q1 q2
r1, r2: T N
Er: equiv r1 r2
Tapart q1 r1 <-> Tapart q2 r2
split;apply apart_respects_aux;
trivial;apply symmetry;trivial.
Qed.

Section to_ring.
Context {B : Type@{UNalt} } `{IsCRing@{UNalt} B}.

Definition to_ring@{} : T N -> B.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H0: IsCRing B
T N -> B
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H0: IsCRing B
T N -> B
intros p.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H0: IsCRing B
p: T N
B
exact (naturals_to_semiring N B (pos p) - naturals_to_semiring N B (neg p)).
Defined.

Lemma to_ring_respects@{} : forall a b, equiv a b ->
  to_ring a = to_ring b.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H0: IsCRing B
forall a b : T N, equiv a b -> to_ring a = to_ring b
Proof.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H0: IsCRing B
forall a b : T N, equiv a b -> to_ring a = to_ring b
unfold equiv;intros [pa na] [pb nb] E.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H0: IsCRing B
pa, na, pb, nb: N
E: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} =
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |}
to_ring {| pos := pa; neg := na |} =
to_ring {| pos := pb; neg := nb |}
unfold to_ring;simpl in *.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H0: IsCRing B
pa, na, pb, nb: N
E: pa + nb = pb + na
naturals_to_semiring N B pa -
naturals_to_semiring N B na =
naturals_to_semiring N B pb -
naturals_to_semiring N B nb
apply (left_cancellation (+)
  (naturals_to_semiring N B na + naturals_to_semiring N B nb)).N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H0: IsCRing B
pa, na, pb, nb: N
E: pa + nb = pb + na
naturals_to_semiring N B na +
naturals_to_semiring N B nb +
(naturals_to_semiring N B pa -
 naturals_to_semiring N B na) =
naturals_to_semiring N B na +
naturals_to_semiring N B nb +
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
path_via (naturals_to_semiring N B pa + naturals_to_semiring N B nb + 0);
[rewrite <-(plus_negate_r (naturals_to_semiring N B na));ring_with_nat
|rewrite plus_0_r].N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H0: IsCRing B
pa, na, pb, nb: N
E: pa + nb = pb + na
naturals_to_semiring N B pa +
naturals_to_semiring N B nb =
naturals_to_semiring N B na +
naturals_to_semiring N B nb +
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
path_via (naturals_to_semiring N B pb + naturals_to_semiring N B na + 0);
[rewrite plus_0_r|
rewrite <-(plus_negate_r (naturals_to_semiring N B nb));ring_with_nat].N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H0: IsCRing B
pa, na, pb, nb: N
E: pa + nb = pb + na
naturals_to_semiring N B pa +
naturals_to_semiring N B nb =
naturals_to_semiring N B pb +
naturals_to_semiring N B na
rewrite <-2!preserves_plus.N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H0: IsCRing B
pa, na, pb, nb: N
E: pa + nb = pb + na
naturals_to_semiring N B (pa + nb) =
naturals_to_semiring N B (pb + na) apply ap,E.
Qed.

End to_ring.

End contents.

Arguments equiv {_ _} _ _.
Arguments Tle {_ _ _} _ _.
Arguments Tlt {_ _ _} _ _.
Arguments Tapart {_ _ _} _ _.
Arguments to_ring N {_} B {_ _ _ _ _ _} / _.

End PairT.

Section contents.
Universe UN UNalt.
Context `{Funext} `{Univalence} (N : Type@{UN})
  `{Naturals@{UN UN UN UN UN UN UN UNalt} N}.

(* Add Ring SR : (rings.stdlib_semiring_theory SR). *)
Instance N_fullpartial : FullPartialOrder Ale Alt
  := fullpseudo_fullpartial@{UN UN UN UN UN UN UN Ularge}.

Definition Z@{} : Type@{UN} := @quotient _ PairT.equiv@{UN UNalt} _.

#[export] Instance Z_of_pair : Cast (PairT.T N) Z := class_of _.

#[export] Instance Z_of_N : Cast N Z := Compose Z_of_pair (PairT.inject@{UN UNalt} _).

Definition Z_path {x y} : PairT.equiv x y -> Z_of_pair x = Z_of_pair y
  := related_classes_eq _.

Definition related_path {x y} : Z_of_pair x = Z_of_pair y -> PairT.equiv x y
  := classes_eq_related@{UN UN Ularge UN Ularge} _ _ _.

Definition Z_rect@{i} (P : Z -> Type@{i}) {sP : forall x, IsHSet (P x)}
  (dclass : forall x : PairT.T N, P (' x))
  (dequiv : forall x y E, (Z_path E) # (dclass x) = (dclass y))
  : forall q, P q
  := quotient_ind PairT.equiv P dclass dequiv.

Definition Z_compute P {sP} dclass dequiv x
 : @Z_rect P sP dclass dequiv (Z_of_pair x) = dclass x := 1.

Definition Z_compute_path P {sP} dclass dequiv q r (E : PairT.equiv q r)
  : apD (@Z_rect P sP dclass dequiv) (Z_path E) = dequiv q r E
  := quotient_ind_compute_path _ _ _ _ _ _ _ _.

Definition Z_ind@{i} (P : Z -> Type@{i}) {sP : forall x : Z, IsHProp (P x)}
  (dclass : forall x : PairT.T N, P (cast (PairT.T N) Z x)) : forall x : Z, P x.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Type
sP: forall x : Z, IsHProp (P x)
dclass: forall x : T N, P (' x)
forall x : Z, P x
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Type
sP: forall x : Z, IsHProp (P x)
dclass: forall x : T N, P (' x)
forall x : Z, P x
apply (Z_rect@{i} P dclass).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Type
sP: forall x : Z, IsHProp (P x)
dclass: forall x : T N, P (' x)
forall (x y : T N) (E : equiv x y),
transport P (Z_path E) (dclass x) = dclass y
intros;apply path_ishprop@{i}.
Defined.

Definition Z_ind2 (P : Z -> Z -> Type) {sP : forall x y, IsHProp (P x y)}
  (dclass : forall x y : PairT.T N, P (' x) (' y)) : forall x y, P x y.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Z -> Type
sP: is_mere_relation Z P
dclass: forall x y : T N, P (' x) (' y)
forall x y : Z, P x y
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Z -> Type
sP: is_mere_relation Z P
dclass: forall x y : T N, P (' x) (' y)
forall x y : Z, P x y
apply (Z_ind (fun x => forall y, _));intros x.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Z -> Type
sP: is_mere_relation Z P
dclass: forall x y : T N, P (' x) (' y)
x: T N
forall y : Z, P (' x) y
apply (Z_ind _);intros y.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Z -> Type
sP: is_mere_relation Z P
dclass: forall x y : T N, P (' x) (' y)
x, y: T N
P (' x) (' y)
apply dclass.
Defined.

Definition Z_ind3@{i j} (P : Z -> Z -> Z -> Type@{i})
  {sP : forall x y z : Z, IsHProp (P x y z)}
  (dclass : forall x y z : PairT.T N, P (' x) (' y) (' z))
  : forall x y z : Z, P x y z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Z -> Z -> Type
sP: forall x y z : Z, IsHProp (P x y z)
dclass: forall x y z : T N, P (' x) (' y) (' z)
forall x y z : Z, P x y z
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Z -> Z -> Type
sP: forall x y z : Z, IsHProp (P x y z)
dclass: forall x y z : T N, P (' x) (' y) (' z)
forall x y z : Z, P x y z
apply (@Z_ind (fun x => forall y z, _));intros x.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Z -> Z -> Type
sP: forall x y z : Z, IsHProp (P x y z)
dclass: forall x y z : T N, P (' x) (' y) (' z)
x: Z
IsHProp (forall y z : Z, P x y z)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Z -> Z -> Type
sP: forall x y z : Z, IsHProp (P x y z)
dclass: forall x y z : T N, P (' x) (' y) (' z)
x: T N
forall y z : Z, P (' x) y z
2:apply (Z_ind2@{i j} _);auto.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Z -> Z -> Type
sP: forall x y z : Z, IsHProp (P x y z)
dclass: forall x y z : T N, P (' x) (' y) (' z)
x: Z
IsHProp (forall y z : Z, P x y z)
apply (@istrunc_forall@{UN j j} _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Z -> Z -> Type
sP: forall x y z : Z, IsHProp (P x y z)
dclass: forall x y z : T N, P (' x) (' y) (' z)
x: Z
forall a : Z, IsHProp (forall z : Z, P x a z)
intros.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
P: Z -> Z -> Z -> Type
sP: forall x y z : Z, IsHProp (P x y z)
dclass: forall x y z : T N, P (' x) (' y) (' z)
x, a: Z
IsHProp (forall z : Z, P x a z) exact istrunc_forall@{UN i j}.
Defined.

Definition Z_rec@{i} {T : Type@{i} } {sT : IsHSet T}
  : forall (dclass : PairT.T N -> T)
  (dequiv : forall x y, PairT.equiv x y -> dclass x = dclass y),
  Z -> T
  := quotient_rec _.

Definition Z_rec_compute T sT dclass dequiv x
  : @Z_rec T sT dclass dequiv (' x) = dclass x
  := 1.

Definition Z_rec2@{i j} {T:Type@{i} } {sT : IsHSet T}
  : forall (dclass : PairT.T N -> PairT.T N -> T)
  (dequiv : forall x1 x2, PairT.equiv x1 x2 -> forall y1 y2, PairT.equiv y1 y2 ->
    dclass x1 y1 = dclass x2 y2),
  Z -> Z -> T
  := @quotient_rec2@{UN UN UN j i} _ _ _ _ _ (Build_HSet _).

Definition Z_rec2_compute {T sT} dclass dequiv x y
  : @Z_rec2 T sT dclass dequiv (' x) (' y) = dclass x y
  := 1.

Lemma dec_Z_of_pair `{DecidablePaths N} : forall q r : PairT.T N,
  Decidable (' q = ' r).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
forall q r : T N, Decidable (' q = ' r)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
forall q r : T N, Decidable (' q = ' r)
intros q r.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
q, r: T N
Decidable (' q = ' r)
destruct (dec (PairT.equiv q r)) as [E|E].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
q, r: T N
E: equiv q r
Decidable (' q = ' r)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
q, r: T N
E: ~ equiv q r
Decidable (' q = ' r)
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
q, r: T N
E: equiv q r
Decidable (' q = ' r) left.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
q, r: T N
E: equiv q r
' q = ' r apply Z_path,E.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
q, r: T N
E: ~ equiv q r
Decidable (' q = ' r) right.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
q, r: T N
E: ~ equiv q r
' q <> ' r intros E'.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
q, r: T N
E: ~ equiv q r
E': ' q = ' r
Empty
  apply E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
q, r: T N
E: ~ equiv q r
E': ' q = ' r
equiv q r exact (related_path E').
Defined.

#[export] Instance R_dec `{DecidablePaths N}
  : DecidablePaths Z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
DecidablePaths Z
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
DecidablePaths Z
hnf.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
forall x y : Z, Decidable (x = y) apply (Z_ind2 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: DecidablePaths N
forall x y : T N, Decidable (' x = ' y)
exact dec_Z_of_pair.
Defined.

(* Relations, operations and constants *)

#[export] Instance Z0 : Zero Z := ' 0.
#[export] Instance Z1 : One Z := ' 1.

#[export] Instance Z_plus@{} : Plus Z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Plus Z
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Plus Z
refine (Z_rec2 (fun x y => ' (PairT.pl@{UN UNalt} _ x y)) _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x1 x2 : T N,
equiv x1 x2 ->
forall y1 y2 : T N,
equiv y1 y2 -> ' pl N x1 y1 = ' pl N x2 y2
intros;apply Z_path;eapply PairT.pl_respects;trivial.
Defined.

Definition Z_plus_compute q r : (' q) + (' r) = ' (PairT.pl _ q r)
  := 1.

#[export] Instance Z_mult@{} : Mult Z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Mult Z
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Mult Z
refine (Z_rec2 (fun x y => ' (PairT.ml@{UN UNalt} _ x y)) _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x1 x2 : T N,
equiv x1 x2 ->
forall y1 y2 : T N,
equiv y1 y2 -> ' ml N x1 y1 = ' ml N x2 y2
intros;apply Z_path;eapply PairT.ml_respects;trivial.
Defined.

(* Without this, typeclass resolution for e.g. [Monoid Z Z_plus] tries to get it from [SemiRing Z Z_plus ?mult] and fills the evar with the unfolded value, which does case analysis on quotient. *)
Global Typeclasses Opaque Z_plus Z_mult.

Definition Z_mult_compute q r : (' q) * (' r) = ' (PairT.ml _ q r)
  := 1.

#[export] Instance Z_negate@{} : Negate Z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Negate Z
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Negate Z
red.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Z -> Z apply (Z_rec (fun x => ' (PairT.opp@{UN UNalt} _ x))).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N, equiv x y -> ' opp N x = ' opp N y
intros;apply Z_path;eapply PairT.opp_respects;trivial.
Defined.

Definition Z_negate_compute q : - (' q) = ' (PairT.opp _ q)
  := 1.

Lemma Z_ring@{} : IsCRing Z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsCRing Z
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsCRing Z
  repeat split.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsHSet Z
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Associative sg_op
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
LeftIdentity sg_op mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
RightIdentity sg_op mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
LeftInverse sg_op inv mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
RightInverse sg_op inv mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Commutative plus
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsHSet Z
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Associative sg_op
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
LeftIdentity sg_op mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
RightIdentity sg_op mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Commutative sg_op
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
LeftDistribute mult plus
  1,8: exact _.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Associative sg_op
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
LeftIdentity sg_op mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
RightIdentity sg_op mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
LeftInverse sg_op inv mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
RightInverse sg_op inv mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Commutative plus
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Associative sg_op
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
LeftIdentity sg_op mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
RightIdentity sg_op mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Commutative sg_op
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
LeftDistribute mult plus
  all: first [change sg_op with mult; change mon_unit with 1 |
       change sg_op with plus; change mon_unit with 0]; hnf.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : Z, x + (y + z) = x + y + z
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall y : Z, 0 + y = y
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : Z, x + 0 = x
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : Z, inv x + x = 0
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : Z, x + inv x = 0
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, x + y = y + x
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : Z, x * (y * z) = x * y * z
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall y : Z, 1 * y = y
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : Z, x * 1 = x
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, x * y = y * x
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall a b c : Z, a * (b + c) = a * b + a * c
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : Z, x + (y + z) = x + y + z apply (Z_ind3 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : T N,
' x + (' y + ' z) = ' x + ' y + ' z
  intros a b c;apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
pos a + (pos b + pos c) + (neg a + neg b + neg c) =
pos a + pos b + pos c + (neg a + (neg b + neg c))
  rewrite !plus_assoc.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
pos a + pos b + pos c + neg a + neg b + neg c =
pos a + pos b + pos c + neg a + neg b + neg c reflexivity.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall y : Z, 0 + y = y apply (Z_ind _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : T N, 0 + ' x = ' x
  intros a;apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a: T N
0 + pos a + neg a = pos a + (0 + neg a)
  rewrite !plus_0_l.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a: T N
pos a + neg a = pos a + neg a reflexivity.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : Z, x + 0 = x apply (Z_ind _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : T N, ' x + 0 = ' x
  intros a;apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a: T N
pos a + 0 + neg a = pos a + (neg a + 0)
  rewrite !plus_0_r.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a: T N
pos a + neg a = pos a + neg a reflexivity.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : Z, inv x + x = 0 apply (Z_ind _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : T N, inv (' x) + ' x = 0
  intros a;apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a: T N
neg a + pos a + 0 = 0 + (pos a + neg a)
  rewrite plus_0_l,plus_0_r.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a: T N
neg a + pos a = pos a + neg a apply plus_comm.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : Z, x + inv x = 0 apply (Z_ind _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : T N, ' x + inv (' x) = 0
  intros a;apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a: T N
pos a + neg a + 0 = 0 + (neg a + pos a)
  rewrite plus_0_l,plus_0_r.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a: T N
pos a + neg a = neg a + pos a apply plus_comm.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, x + y = y + x apply (Z_ind2 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N, ' x + ' y = ' y + ' x
  intros a b;apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: T N
pos a + pos b + (neg b + neg a) =
pos b + pos a + (neg a + neg b)
  apply ap011;apply plus_comm.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : Z, x * (y * z) = x * y * z apply (Z_ind3 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : T N,
' x * (' y * ' z) = ' x * ' y * ' z
  intros [pa na] [pb nb] [pc nc];apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
pa * (pb * pc + nb * nc) + na * (pb * nc + nb * pc) +
((pa * pb + na * nb) * nc + (pa * nb + na * pb) * pc) =
(pa * pb + na * nb) * pc + (pa * nb + na * pb) * nc +
(pa * (pb * nc + nb * pc) + na * (pb * pc + nb * nc))
  ring_with_nat.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall y : Z, 1 * y = y apply (Z_ind _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : T N, 1 * ' x = ' x
  intros;apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x: T N
1 * pos x + 0 * neg x + neg x =
pos x + (1 * neg x + 0 * pos x)
  ring_with_nat.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : Z, x * 1 = x apply (Z_ind _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : T N, ' x * 1 = ' x
  intros;apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x: T N
pos x * 1 + neg x * 0 + neg x =
pos x + (pos x * 0 + neg x * 1)
  ring_with_nat.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, x * y = y * x apply (Z_ind2 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N, ' x * ' y = ' y * ' x
  intros;apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: T N
pos x * pos y + neg x * neg y +
(pos y * neg x + neg y * pos x) =
pos y * pos x + neg y * neg x +
(pos x * neg y + neg x * pos y)
  ring_with_nat.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall a b c : Z, a * (b + c) = a * b + a * c apply (Z_ind3 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : T N,
' x * (' y + ' z) = ' x * ' y + ' x * ' z
  intros [pa na] [pb nb] [pc nc];apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
pa * (pb + pc) + na * (nb + nc) +
(pa * nb + na * pb + (pa * nc + na * pc)) =
pa * pb + na * nb + (pa * pc + na * nc) +
(pa * (nb + nc) + na * (pb + pc))
  ring_with_nat.
Qed.

(* A final word about inject *)
Lemma Z_of_N_morphism@{} : IsSemiRingPreserving (cast N Z).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsSemiRingPreserving (cast N Z)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsSemiRingPreserving (cast N Z)
repeat (constructor; try exact _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsSemiGroupPreserving (cast N Z)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsSemiGroupPreserving (cast N Z)
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsSemiGroupPreserving (cast N Z) intros x y.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
' sg_op x y = sg_op (' x) (' y)
  apply Z_path.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
equiv (inject N (sg_op x y))
  (pl N (inject N x) (inject N y)) red.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
pos (inject N (sg_op x y)) +
neg (pl N (inject N x) (inject N y)) =
pos (pl N (inject N x) (inject N y)) +
neg (inject N (sg_op x y)) simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
sg_op x y + (0 + 0) = x + y + 0 ring_with_nat.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsSemiGroupPreserving (cast N Z) intros x y.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
' sg_op x y = sg_op (' x) (' y) apply Z_path.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
equiv (inject N (sg_op x y))
  (ml N (inject N x) (inject N y)) red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
sg_op x y + (x * 0 + 0 * y) = x * y + 0 * 0 + 0
  ring_with_nat.
Qed.
Existing Instance Z_of_N_morphism.

#[export] Instance Z_of_N_injective@{} : IsInjective (cast N Z).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsInjective (cast N Z)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsInjective (cast N Z)
intros x y E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
E: ' x = ' y
x = y apply related_path in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
E: equiv (inject N x) (inject N y)
x = y
red in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
E: pos (inject N x) + neg (inject N y) =
pos (inject N y) + neg (inject N x)
x = y simpl in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
E: x + 0 = y + 0
x = y rewrite 2!plus_0_r in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
E: x = y
x = y trivial.
Qed.

Lemma Npair_splits@{} : forall n m : N, ' (PairT.C n m) = ' n + - ' m.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall n m : N, ' {| pos := n; neg := m |} = ' n - ' m
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall n m : N, ' {| pos := n; neg := m |} = ' n - ' m
intros.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
n, m: N
' {| pos := n; neg := m |} = ' n - ' m
apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
n, m: N
n + (0 + m) = n + 0 + m
ring_with_nat.
Qed.

Definition Zle_HProp@{} : Z -> Z -> HProp@{UN}.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Z -> Z -> HProp
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Z -> Z -> HProp
apply (@Z_rec2@{Ularge Ularge} _ (@trunctype_istrunc@{Ularge} _ _)
  (fun q r => Build_HProp (PairT.Tle q r))).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x1 x2 : T N,
equiv x1 x2 ->
forall y1 y2 : T N,
equiv y1 y2 ->
Build_HProp (Tle x1 y1) = Build_HProp (Tle x2 y2)
intros.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x1, x2: T N
X: equiv x1 x2
y1, y2: T N
X0: equiv y1 y2
Build_HProp (Tle x1 y1) = Build_HProp (Tle x2 y2) apply path_hprop.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x1, x2: T N
X: equiv x1 x2
y1, y2: T N
X0: equiv y1 y2
Build_HProp (Tle x1 y1) <~> Build_HProp (Tle x2 y2) simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x1, x2: T N
X: equiv x1 x2
y1, y2: T N
X0: equiv y1 y2
Tle x1 y1 <~> Tle x2 y2
apply (PairT.le_respects _);trivial.
Defined.

#[export] Instance Zle@{} : Le Z := fun x y => Zle_HProp x y.

#[export] Instance ishprop_Zle : is_mere_relation _ Zle.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
is_mere_relation Z Zle
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
is_mere_relation Z Zle unfold Zle;exact _. Qed.

Lemma Zle_def@{} : forall a b : PairT.T N,
  @paths@{Uhuge} Type@{UN} (' a <= ' b) (PairT.Tle@{UN UNalt} a b).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall a b : T N, (' a ≤ ' b) = Tle a b
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall a b : T N, (' a ≤ ' b) = Tle a b intros; exact idpath. Qed.

Lemma Z_partial_order' : PartialOrder Zle.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
PartialOrder Zle
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
PartialOrder Zle
split;[apply _|apply _|split|].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Reflexive le
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Transitive le
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
AntiSymmetric le
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Reflexive le hnf.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : Z, x ≤ x apply (Z_ind _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : T N, ' x ≤ ' x
  intros.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x: T N
' x ≤ ' x change (PairT.Tle x x).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x: T N
Tle x x red.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x: T N
pos x + neg x ≤ pos x + neg x reflexivity.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Transitive le hnf.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : Z, x ≤ y -> y ≤ z -> x ≤ z apply (Z_ind3 (fun _ _ _ => _ -> _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : T N,
' x ≤ ' y -> ' y ≤ ' z -> ' x ≤ ' z
  intros [pa na] [pb nb] [pc nc].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
' {| pos := pa; neg := na |}
≤ ' {| pos := pb; neg := nb |} ->
' {| pos := pb; neg := nb |}
≤ ' {| pos := pc; neg := nc |} ->
' {| pos := pa; neg := na |}
≤ ' {| pos := pc; neg := nc |} rewrite !Zle_def;unfold PairT.Tle;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
pa + nb ≤ pb + na ->
pb + nc ≤ pc + nb -> pa + nc ≤ pc + na
  intros E1 E2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb ≤ pb + na
E2: pb + nc ≤ pc + nb
pa + nc ≤ pc + na
  apply (order_reflecting (+ (nb + pb))).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb ≤ pb + na
E2: pb + nc ≤ pc + nb
pa + nc + (nb + pb) ≤ pc + na + (nb + pb)
  assert (Hrw : pa + nc + (nb + pb) = (pa + nb) + (pb + nc))
    by abstract ring_with_nat.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb ≤ pb + na
E2: pb + nc ≤ pc + nb
Hrw: pa + nc + (nb + pb) = pa + nb + (pb + nc)
pa + nc + (nb + pb) ≤ pc + na + (nb + pb)
  rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb ≤ pb + na
E2: pb + nc ≤ pc + nb
pa + nb + (pb + nc) ≤ pc + na + (nb + pb)
  assert (Hrw : pc + na + (nb + pb) = (pb + na) + (pc + nb))
    by abstract ring_with_nat.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb ≤ pb + na
E2: pb + nc ≤ pc + nb
Hrw: pc + na + (nb + pb) = pb + na + (pc + nb)
pa + nb + (pb + nc) ≤ pc + na + (nb + pb)
  rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb ≤ pb + na
E2: pb + nc ≤ pc + nb
pa + nb + (pb + nc) ≤ pb + na + (pc + nb)
  apply plus_le_compat;trivial.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
AntiSymmetric le hnf.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, x ≤ y -> y ≤ x -> x = y apply (Z_ind2 (fun _ _ => _ -> _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N, ' x ≤ ' y -> ' y ≤ ' x -> ' x = ' y
  intros [pa na] [pb nb];rewrite !Zle_def;unfold PairT.Tle;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
pa + nb ≤ pb + na ->
pb + na ≤ pa + nb ->
' {| pos := pa; neg := na |} =
' {| pos := pb; neg := nb |}
  intros E1 E2;apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: pa + nb ≤ pb + na
E2: pb + na ≤ pa + nb
pa + nb = pb + na
  apply (antisymmetry le);trivial.
Qed.

(* Coq pre 8.8 produces phantom universes, see GitHub Coq/Coq#1033. *)
Instance Z_partial_order@{} : PartialOrder Zle
  := ltac:(first [exact Z_partial_order'@{Ularge Ularge Ularge Ularge Ularge}|
                  exact Z_partial_order']).

Lemma Zle_cast_embedding' : OrderEmbedding (cast N Z).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
OrderEmbedding (cast N Z)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
OrderEmbedding (cast N Z)
split;red.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : N, x ≤ y -> ' x ≤ ' y
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : N, ' x ≤ ' y -> x ≤ y
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : N, x ≤ y -> ' x ≤ ' y intros.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
X: x ≤ y
' x ≤ ' y rewrite Zle_def.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
X: x ≤ y
Tle (inject N x) (inject N y) unfold PairT.Tle.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
X: x ≤ y
pos (inject N x) + neg (inject N y)
≤ pos (inject N y) + neg (inject N x) simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
X: x ≤ y
x + 0 ≤ y + 0
  rewrite 2!plus_0_r;trivial.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : N, ' x ≤ ' y -> x ≤ y intros ??.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
' x ≤ ' y -> x ≤ y rewrite Zle_def.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
Tle (inject N x) (inject N y) -> x ≤ y unfold PairT.Tle.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
pos (inject N x) + neg (inject N y)
≤ pos (inject N y) + neg (inject N x) -> x ≤ y simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x, y: N
x + 0 ≤ y + 0 -> x ≤ y
  rewrite 2!plus_0_r;trivial.
Qed.

(* Coq pre 8.8 produces phantom universes, see GitHub Coq/Coq#1033. *)
#[export] Instance Zle_cast_embedding@{} : OrderEmbedding (cast N Z)
  := ltac:(first [exact Zle_cast_embedding'@{Ularge Ularge}|
                  exact Zle_cast_embedding']).

Lemma Zle_plus_preserving_l' : forall z : Z, OrderPreserving ((+) z).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall z : Z, OrderPreserving (plus z)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall z : Z, OrderPreserving (plus z)
red.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall z x y : Z, x ≤ y -> z + x ≤ z + y
apply (Z_ind3 (fun _ _ _ => _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : T N, ' y ≤ ' z -> ' x + ' y ≤ ' x + ' z
intros [pc nc] [pa na] [pb nb].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pc, nc, pa, na, pb, nb: N
' {| pos := pa; neg := na |}
≤ ' {| pos := pb; neg := nb |} ->
' {| pos := pc; neg := nc |} +
' {| pos := pa; neg := na |}
≤ ' {| pos := pc; neg := nc |} +
  ' {| pos := pb; neg := nb |} rewrite !Zle_def;unfold PairT.Tle;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pc, nc, pa, na, pb, nb: N
pa + nb ≤ pb + na ->
pc + pa + (nc + nb) ≤ pc + pb + (nc + na)
intros E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pc, nc, pa, na, pb, nb: N
E: pa + nb ≤ pb + na
pc + pa + (nc + nb) ≤ pc + pb + (nc + na)
assert (Hrw : pc + pa + (nc + nb) = (pc + nc) + (pa + nb)) by ring_with_nat.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pc, nc, pa, na, pb, nb: N
E: pa + nb ≤ pb + na
Hrw: pc + pa + (nc + nb) = pc + nc + (pa + nb)
pc + pa + (nc + nb) ≤ pc + pb + (nc + na)
rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pc, nc, pa, na, pb, nb: N
E: pa + nb ≤ pb + na
pc + nc + (pa + nb) ≤ pc + pb + (nc + na)
assert (Hrw : pc + pb + (nc + na) = (pc + nc) + (pb + na)) by ring_with_nat.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pc, nc, pa, na, pb, nb: N
E: pa + nb ≤ pb + na
Hrw: pc + pb + (nc + na) = pc + nc + (pb + na)
pc + nc + (pa + nb) ≤ pc + pb + (nc + na)
rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pc, nc, pa, na, pb, nb: N
E: pa + nb ≤ pb + na
pc + nc + (pa + nb) ≤ pc + nc + (pb + na)
apply (order_preserving _),E.
Qed.

(* Coq pre 8.8 produces phantom universes, see GitHub Coq/Coq#1033. *)
Instance Zle_plus_preserving_l@{} : forall z : Z, OrderPreserving ((+) z)
  := ltac:(first [exact Zle_plus_preserving_l'@{Ularge Ularge}|
                  exact Zle_plus_preserving_l']).

Lemma Zmult_nonneg' : forall x y : Z, PropHolds (0 ≤ x) -> PropHolds (0 ≤ y) ->
  PropHolds (0 ≤ x * y).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z,
PropHolds (0 ≤ x) ->
PropHolds (0 ≤ y) -> PropHolds (0 ≤ x * y)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z,
PropHolds (0 ≤ x) ->
PropHolds (0 ≤ y) -> PropHolds (0 ≤ x * y)
unfold PropHolds.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, 0 ≤ x -> 0 ≤ y -> 0 ≤ x * y
apply (Z_ind2 (fun _ _ => _ -> _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N, 0 ≤ ' x -> 0 ≤ ' y -> 0 ≤ ' x * ' y
intros [pa na] [pb nb].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
0 ≤ ' {| pos := pa; neg := na |} ->
0 ≤ ' {| pos := pb; neg := nb |} ->
0
≤ ' {| pos := pa; neg := na |} *
  ' {| pos := pb; neg := nb |} rewrite !Zle_def;unfold PairT.Tle;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
0 + na ≤ pa + 0 ->
0 + nb ≤ pb + 0 ->
0 + (pa * nb + na * pb) ≤ pa * pb + na * nb + 0
rewrite !plus_0_l,!plus_0_r.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
na ≤ pa ->
nb ≤ pb -> pa * nb + na * pb ≤ pa * pb + na * nb
intros E1 E2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na ≤ pa
E2: nb ≤ pb
pa * nb + na * pb ≤ pa * pb + na * nb
destruct (decompose_le E1) as [a [Ea1 Ea2]], (decompose_le E2) as [b [Eb1 Eb2]].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na ≤ pa
E2: nb ≤ pb
a: N
Ea1: 0 ≤ a
Ea2: pa = na + a
b: N
Eb1: 0 ≤ b
Eb2: pb = nb + b
pa * nb + na * pb ≤ pa * pb + na * nb
rewrite Ea2, Eb2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na ≤ pa
E2: nb ≤ pb
a: N
Ea1: 0 ≤ a
Ea2: pa = na + a
b: N
Eb1: 0 ≤ b
Eb2: pb = nb + b
(na + a) * nb + na * (nb + b)
≤ (na + a) * (nb + b) + na * nb
apply compose_le with (a * b).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na ≤ pa
E2: nb ≤ pb
a: N
Ea1: 0 ≤ a
Ea2: pa = na + a
b: N
Eb1: 0 ≤ b
Eb2: pb = nb + b
0 ≤ a * b
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na ≤ pa
E2: nb ≤ pb
a: N
Ea1: 0 ≤ a
Ea2: pa = na + a
b: N
Eb1: 0 ≤ b
Eb2: pb = nb + b
(na + a) * (nb + b) + na * nb =
(na + a) * nb + na * (nb + b) + a * b
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na ≤ pa
E2: nb ≤ pb
a: N
Ea1: 0 ≤ a
Ea2: pa = na + a
b: N
Eb1: 0 ≤ b
Eb2: pb = nb + b
0 ≤ a * b apply nonneg_mult_compat;trivial.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na ≤ pa
E2: nb ≤ pb
a: N
Ea1: 0 ≤ a
Ea2: pa = na + a
b: N
Eb1: 0 ≤ b
Eb2: pb = nb + b
(na + a) * (nb + b) + na * nb =
(na + a) * nb + na * (nb + b) + a * b ring_with_nat.
Qed.

(* Coq pre 8.8 produces phantom universes, see GitHub Coq/Coq#1033. *)
Instance Zmult_nonneg@{} : forall x y : Z, PropHolds (0 ≤ x) -> PropHolds (0 ≤ y) ->
  PropHolds (0 ≤ x * y)
  := ltac:(first [exact Zmult_nonneg'@{Ularge Ularge Ularge}|
                  exact Zmult_nonneg']).

#[export] Instance Z_order@{} : SemiRingOrder Zle.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
SemiRingOrder Zle
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
SemiRingOrder Zle pose proof Z_ring; apply rings.from_ring_order; exact _. Qed.

(* Make this computable? Would need to compute through Z_ind2. *)
#[export] Instance Zle_dec `{forall x y : N, Decidable (x <= y)}
  : forall x y : Z, Decidable (x <= y).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x ≤ y)
forall x y : Z, Decidable (x ≤ y)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x ≤ y)
forall x y : Z, Decidable (x ≤ y)
apply (Z_ind2 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x ≤ y)
forall x y : T N, Decidable (' x ≤ ' y)
intros a b.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x ≤ y)
a, b: T N
Decidable (' a ≤ ' b) change (Decidable (PairT.Tle a b)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x ≤ y)
a, b: T N
Decidable (Tle a b)
unfold PairT.Tle.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x ≤ y)
a, b: T N
Decidable (pos a + neg b ≤ pos b + neg a) exact _.
Qed.

Definition Zlt_HProp@{} : Z -> Z -> HProp@{UN}.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Z -> Z -> HProp
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Z -> Z -> HProp
apply (@Z_rec2@{Ularge Ularge} _ (@trunctype_istrunc@{Ularge} _ _)
  (fun q r => Build_HProp (PairT.Tlt q r))).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x1 x2 : T N,
equiv x1 x2 ->
forall y1 y2 : T N,
equiv y1 y2 ->
Build_HProp (Tlt x1 y1) = Build_HProp (Tlt x2 y2)
intros.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x1, x2: T N
X: equiv x1 x2
y1, y2: T N
X0: equiv y1 y2
Build_HProp (Tlt x1 y1) = Build_HProp (Tlt x2 y2) apply path_hprop.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x1, x2: T N
X: equiv x1 x2
y1, y2: T N
X0: equiv y1 y2
Build_HProp (Tlt x1 y1) <~> Build_HProp (Tlt x2 y2) simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x1, x2: T N
X: equiv x1 x2
y1, y2: T N
X0: equiv y1 y2
Tlt x1 y1 <~> Tlt x2 y2
apply (PairT.lt_respects _);trivial.
Defined.

#[export] Instance Zlt@{} : Lt Z := fun x y => Zlt_HProp x y.

#[export] Instance ishprop_Zlt : is_mere_relation _ Zlt.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
is_mere_relation Z Zlt
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
is_mere_relation Z Zlt unfold Zlt;exact _. Qed.

Lemma Zlt_def' : forall a b, ' a < ' b = PairT.Tlt a b.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall a b : T N, (' a < ' b) = Tlt a b
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall a b : T N, (' a < ' b) = Tlt a b reflexivity. Qed.

(* Coq pre 8.8 produces phantom universes, see GitHub Coq/Coq#1033. *)
Definition Zlt_def@{i} := ltac:(first [exact Zlt_def'@{Uhuge i}|exact Zlt_def'@{i}]).

Lemma Zlt_strict' : StrictOrder Zlt.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
StrictOrder Zlt
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
StrictOrder Zlt
split.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
is_mere_relation Z lt
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Irreflexive lt
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Transitive lt
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
is_mere_relation Z lt exact _.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Irreflexive lt (* we need to change so that it sees Empty,
     needed to figure out IsHProp (using Funext) *)
  change (forall x, x < x -> Empty).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : Z, x < x -> Empty apply (Z_ind (fun _ => _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x : T N, ' x < ' x -> Empty
  intros [pa na];rewrite Zlt_def;unfold PairT.Tlt;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na: N
pa + na < pa + na -> Empty
  apply irreflexivity,_.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Transitive lt hnf.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : Z, x < y -> y < z -> x < z apply (Z_ind3 (fun _ _ _ => _ -> _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : T N,
' x < ' y -> ' y < ' z -> ' x < ' z
  intros [pa na] [pb nb] [pc nc];rewrite !Zlt_def;unfold PairT.Tlt;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
pa + nb < pb + na ->
pb + nc < pc + nb -> pa + nc < pc + na
  intros E1 E2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb < pb + na
E2: pb + nc < pc + nb
pa + nc < pc + na
  apply (strictly_order_reflecting (+ (nb + pb))).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb < pb + na
E2: pb + nc < pc + nb
pa + nc + (nb + pb) < pc + na + (nb + pb)
  assert (Hrw : pa + nc + (nb + pb) = (pa + nb) + (pb + nc)) by ring_with_nat.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb < pb + na
E2: pb + nc < pc + nb
Hrw: pa + nc + (nb + pb) = pa + nb + (pb + nc)
pa + nc + (nb + pb) < pc + na + (nb + pb)
  rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb < pb + na
E2: pb + nc < pc + nb
pa + nb + (pb + nc) < pc + na + (nb + pb)
  assert (Hrw : pc + na + (nb + pb) = (pb + na) + (pc + nb)) by ring_with_nat.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb < pb + na
E2: pb + nc < pc + nb
Hrw: pc + na + (nb + pb) = pb + na + (pc + nb)
pa + nb + (pb + nc) < pc + na + (nb + pb)
  rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pa + nb < pb + na
E2: pb + nc < pc + nb
pa + nb + (pb + nc) < pb + na + (pc + nb)
  apply plus_lt_compat;trivial.
Qed.

Instance Zlt_strict@{} : StrictOrder Zlt
  := ltac:(first [exact Zlt_strict'@{Ularge Ularge Ularge Ularge Ularge}|
                  exact Zlt_strict'@{}]).

Lemma plus_strict_order_preserving_l'
  : forall z : Z, StrictlyOrderPreserving ((+) z).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall z : Z, StrictlyOrderPreserving (plus z)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall z : Z, StrictlyOrderPreserving (plus z)
red; apply (Z_ind3 (fun _ _ _ => _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : T N, ' y < ' z -> ' x + ' y < ' x + ' z
intros [pa na] [pb nb] [pc nc].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
' {| pos := pb; neg := nb |} <
' {| pos := pc; neg := nc |} ->
' {| pos := pa; neg := na |} +
' {| pos := pb; neg := nb |} <
' {| pos := pa; neg := na |} +
' {| pos := pc; neg := nc |}
rewrite !Zlt_def;unfold PairT.Tlt;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
pb + nc < pc + nb ->
pa + pb + (na + nc) < pa + pc + (na + nb)
intros E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E: pb + nc < pc + nb
pa + pb + (na + nc) < pa + pc + (na + nb)
assert (Hrw : pa + pb + (na + nc) = (pa + na) + (pb + nc)) by ring_with_nat.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E: pb + nc < pc + nb
Hrw: pa + pb + (na + nc) = pa + na + (pb + nc)
pa + pb + (na + nc) < pa + pc + (na + nb)
rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E: pb + nc < pc + nb
pa + na + (pb + nc) < pa + pc + (na + nb)
assert (Hrw : pa + pc + (na + nb) = (pa + na) + (pc + nb)) by ring_with_nat.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E: pb + nc < pc + nb
Hrw: pa + pc + (na + nb) = pa + na + (pc + nb)
pa + na + (pb + nc) < pa + pc + (na + nb)
rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E: pb + nc < pc + nb
pa + na + (pb + nc) < pa + na + (pc + nb)
apply (strictly_order_preserving _),E.
Qed.

Instance Zplus_strict_order_preserving_l@{}
  : forall z : Z, StrictlyOrderPreserving ((+) z)
  := ltac:(first [exact plus_strict_order_preserving_l'@{Ularge Ularge}|
                  exact plus_strict_order_preserving_l'@{}]).

Lemma Zmult_pos' : forall x y : Z, PropHolds (0 < x) -> PropHolds (0 < y) ->
  PropHolds (0 < x * y).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z,
PropHolds (0 < x) ->
PropHolds (0 < y) -> PropHolds (0 < x * y)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z,
PropHolds (0 < x) ->
PropHolds (0 < y) -> PropHolds (0 < x * y)
unfold PropHolds.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, 0 < x -> 0 < y -> 0 < x * y
apply (Z_ind2 (fun _ _ => _ -> _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N, 0 < ' x -> 0 < ' y -> 0 < ' x * ' y
intros [pa na] [pb nb].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
0 < ' {| pos := pa; neg := na |} ->
0 < ' {| pos := pb; neg := nb |} ->
0 <
' {| pos := pa; neg := na |} *
' {| pos := pb; neg := nb |} rewrite !Zlt_def;unfold PairT.Tlt;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
0 + na < pa + 0 ->
0 + nb < pb + 0 ->
0 + (pa * nb + na * pb) < pa * pb + na * nb + 0
rewrite !plus_0_l,!plus_0_r.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
na < pa ->
nb < pb -> pa * nb + na * pb < pa * pb + na * nb
intros E1 E2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na < pa
E2: nb < pb
pa * nb + na * pb < pa * pb + na * nb
destruct (decompose_lt E1) as [a [Ea1 Ea2]], (decompose_lt E2) as [b [Eb1 Eb2]].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na < pa
E2: nb < pb
a: N
Ea1: 0 < a
Ea2: pa = na + a
b: N
Eb1: 0 < b
Eb2: pb = nb + b
pa * nb + na * pb < pa * pb + na * nb
rewrite Ea2, Eb2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na < pa
E2: nb < pb
a: N
Ea1: 0 < a
Ea2: pa = na + a
b: N
Eb1: 0 < b
Eb2: pb = nb + b
(na + a) * nb + na * (nb + b) <
(na + a) * (nb + b) + na * nb
apply compose_lt with (a * b).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na < pa
E2: nb < pb
a: N
Ea1: 0 < a
Ea2: pa = na + a
b: N
Eb1: 0 < b
Eb2: pb = nb + b
0 < a * b
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na < pa
E2: nb < pb
a: N
Ea1: 0 < a
Ea2: pa = na + a
b: N
Eb1: 0 < b
Eb2: pb = nb + b
(na + a) * (nb + b) + na * nb =
(na + a) * nb + na * (nb + b) + a * b
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na < pa
E2: nb < pb
a: N
Ea1: 0 < a
Ea2: pa = na + a
b: N
Eb1: 0 < b
Eb2: pb = nb + b
0 < a * b apply pos_mult_compat;trivial.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
E1: na < pa
E2: nb < pb
a: N
Ea1: 0 < a
Ea2: pa = na + a
b: N
Eb1: 0 < b
Eb2: pb = nb + b
(na + a) * (nb + b) + na * nb =
(na + a) * nb + na * (nb + b) + a * b ring_with_nat.
Qed.

Instance Zmult_pos@{} : forall x y : Z, PropHolds (0 < x) -> PropHolds (0 < y) ->
  PropHolds (0 < x * y)
  := ltac:(first [exact Zmult_pos'@{Ularge Ularge Ularge}|
                  exact Zmult_pos'@{}]).

#[export] Instance Z_strict_srorder : StrictSemiRingOrder Zlt.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
StrictSemiRingOrder Zlt
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
StrictSemiRingOrder Zlt pose proof Z_ring; apply from_strict_ring_order; exact _. Qed.

#[export] Instance Zlt_dec `{forall x y : N, Decidable (x < y)}
  : forall x y : Z, Decidable (x < y).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x < y)
forall x y : Z, Decidable (x < y)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x < y)
forall x y : Z, Decidable (x < y)
apply (Z_ind2 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x < y)
forall x y : T N, Decidable (' x < ' y)
intros a b.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x < y)
a, b: T N
Decidable (' a < ' b) change (Decidable (PairT.Tlt a b)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x < y)
a, b: T N
Decidable (Tlt a b)
unfold PairT.Tlt.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
H2: forall x y : N, Decidable (x < y)
a, b: T N
Decidable (pos a + neg b < pos b + neg a)
exact _.
Qed.

Local Existing Instance pseudo_order_apart.

Definition Zapart_HProp@{} : Z -> Z -> HProp@{UN}.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Z -> Z -> HProp
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Z -> Z -> HProp
apply (@Z_rec2@{Ularge Ularge} _ _
  (fun q r => Build_HProp (PairT.Tapart q r))).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x1 x2 : T N,
equiv x1 x2 ->
forall y1 y2 : T N,
equiv y1 y2 ->
Build_HProp (Tapart x1 y1) =
Build_HProp (Tapart x2 y2)
intros.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x1, x2: T N
X: equiv x1 x2
y1, y2: T N
X0: equiv y1 y2
Build_HProp (Tapart x1 y1) =
Build_HProp (Tapart x2 y2) apply path_hprop.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x1, x2: T N
X: equiv x1 x2
y1, y2: T N
X0: equiv y1 y2
Build_HProp (Tapart x1 y1) <~>
Build_HProp (Tapart x2 y2) simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
x1, x2: T N
X: equiv x1 x2
y1, y2: T N
X0: equiv y1 y2
Tapart x1 y1 <~> Tapart x2 y2
apply (PairT.apart_respects _);trivial.
Defined.

#[export] Instance Zapart@{} : Apart Z := fun x y => Zapart_HProp x y.

Lemma Zapart_def' : forall a b, apart (' a) (' b) = PairT.Tapart a b.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall a b : T N, (' a ≶ ' b) = Tapart a b
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall a b : T N, (' a ≶ ' b) = Tapart a b reflexivity. Qed.

(* Coq pre 8.8 produces phantom universes, see GitHub Coq/Coq#1033. *)
Definition Zapart_def@{i} := ltac:(first [exact Zapart_def'@{Uhuge i}|
                                          exact Zapart_def'@{i}]).

#[export] Instance ishprop_Zapart : is_mere_relation _ Zapart.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
is_mere_relation Z Zapart
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
is_mere_relation Z Zapart unfold Zapart;exact _. Qed.

Lemma Z_trivial_apart' `{!TrivialApart N}
  : TrivialApart Z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
TrivialApart Z
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
TrivialApart Z
split;[exact _|idtac].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
forall x y : Z, x ≶ y <-> x <> y
apply (Z_ind2 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
forall x y : T N, ' x ≶ ' y <-> ' x <> ' y
intros [pa na] [pb nb];rewrite Zapart_def;unfold PairT.Tapart;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
pa + nb ≶ pb + na <->
' {| pos := pa; neg := na |} <>
' {| pos := pb; neg := nb |}
split;intros E1.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: pa + nb ≶ pb + na
' {| pos := pa; neg := na |} <>
' {| pos := pb; neg := nb |}
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: ' {| pos := pa; neg := na |} <>
' {| pos := pb; neg := nb |}
pa + nb ≶ pb + na
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: pa + nb ≶ pb + na
' {| pos := pa; neg := na |} <>
' {| pos := pb; neg := nb |} intros E2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: pa + nb ≶ pb + na
E2: ' {| pos := pa; neg := na |} =
' {| pos := pb; neg := nb |}
Empty apply related_path in E2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: pa + nb ≶ pb + na
E2: equiv {| pos := pa; neg := na |}
  {| pos := pb; neg := nb |}
Empty
  red in E2;simpl in E2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: pa + nb ≶ pb + na
E2: pa + nb = pb + na
Empty
  apply trivial_apart in E1.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: pa + nb <> pb + na
E2: pa + nb = pb + na
Empty auto.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: ' {| pos := pa; neg := na |} <>
' {| pos := pb; neg := nb |}
pa + nb ≶ pb + na apply trivial_apart.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: ' {| pos := pa; neg := na |} <>
' {| pos := pb; neg := nb |}
pa + nb <> pb + na intros E2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: ' {| pos := pa; neg := na |} <>
' {| pos := pb; neg := nb |}
E2: pa + nb = pb + na
Empty
  apply E1,Z_path.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: ' {| pos := pa; neg := na |} <>
' {| pos := pb; neg := nb |}
E2: pa + nb = pb + na
equiv {| pos := pa; neg := na |}
  {| pos := pb; neg := nb |} red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
TrivialApart0: TrivialApart N
pa, na, pb, nb: N
E1: ' {| pos := pa; neg := na |} <>
' {| pos := pb; neg := nb |}
E2: pa + nb = pb + na
pa + nb = pb + na trivial.
Qed.

#[export] Instance Z_trivial_apart@{} `{!TrivialApart N}
  : TrivialApart Z
  := ltac:(first [exact Z_trivial_apart'@{Ularge}|
                  exact Z_trivial_apart'@{}]).

Lemma Z_is_apart' : IsApart Z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsApart Z
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsApart Z
split.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsHSet Z
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
is_mere_relation Z apart
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Symmetric apart
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
CoTransitive apart
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, ~ (x ≶ y) <-> x = y
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsHSet Z apply _.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
is_mere_relation Z apart apply _.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Symmetric apart hnf.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, x ≶ y -> y ≶ x apply (Z_ind2 (fun _ _ => _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N, ' x ≶ ' y -> ' y ≶ ' x
  intros [pa na] [pb nb];rewrite !Zapart_def;unfold PairT.Tapart;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb: N
pa + nb ≶ pb + na -> pb + na ≶ pa + nb
  apply symmetry.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
CoTransitive apart hnf.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z,
x ≶ y -> forall z : Z, hor (x ≶ z) (z ≶ y) intros x y E z;revert x y z E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : Z, x ≶ y -> hor (x ≶ z) (z ≶ y)
  apply (Z_ind3 (fun _ _ _ => _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : T N,
' x ≶ ' y -> hor (' x ≶ ' z) (' z ≶ ' y)
  intros a b c;rewrite !Zapart_def;unfold PairT.Tapart;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
pos a + neg b ≶ pos b + neg a ->
Tr (-1)
  ((plus (pos a) (neg c) ≶ plus (pos c) (neg a)) +
   (plus (pos c) (neg b) ≶ plus (pos b) (neg c)))%type
  intros E1.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: pos a + neg b ≶ pos b + neg a
Tr (-1)
  ((plus (pos a) (neg c) ≶ plus (pos c) (neg a)) +
   (plus (pos c) (neg b) ≶ plus (pos b) (neg c)))%type
  apply (strong_left_cancellation (+) (PairT.neg c)) in E1.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: neg c + (pos a + neg b) ≶ neg c + (pos b + neg a)
Tr (-1)
  ((plus (pos a) (neg c) ≶ plus (pos c) (neg a)) +
   (plus (pos c) (neg b) ≶ plus (pos b) (neg c)))%type
  eapply (merely_destruct (cotransitive E1 _));intros [E2|E2];apply tr.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: neg c + (pos a + neg b) ≶ neg c + (pos b + neg a)
E2: neg c + (pos a + neg b) ≶ ?z
((plus (pos a) (neg c) ≶ plus (pos c) (neg a)) +
 (plus (pos c) (neg b) ≶ plus (pos b) (neg c)))%type
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: neg c + (pos a + neg b) ≶ neg c + (pos b + neg a)
E2: ?z ≶ neg c + (pos b + neg a)
((plus (pos a) (neg c) ≶ plus (pos c) (neg a)) +
 (plus (pos c) (neg b) ≶ plus (pos b) (neg c)))%type
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: neg c + (pos a + neg b) ≶ neg c + (pos b + neg a)
E2: neg c + (pos a + neg b) ≶ ?z
((plus (pos a) (neg c) ≶ plus (pos c) (neg a)) +
 (plus (pos c) (neg b) ≶ plus (pos b) (neg c)))%type left.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: neg c + (pos a + neg b) ≶ neg c + (pos b + neg a)
E2: neg c + (pos a + neg b) ≶ ?z
pos a + neg c ≶ pos c + neg a apply (strong_extensionality (+ (PairT.neg b))).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: neg c + (pos a + neg b) ≶ neg c + (pos b + neg a)
E2: neg c + (pos a + neg b) ≶ ?z
pos a + neg c + neg b ≶ pos c + neg a + neg b
    assert (Hrw : PairT.pos a + PairT.neg c + PairT.neg b =
      PairT.neg c + (PairT.pos a + PairT.neg b))
    by ring_with_nat;rewrite Hrw;exact E2.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: neg c + (pos a + neg b) ≶ neg c + (pos b + neg a)
E2: pos c + neg a + neg b ≶ neg c + (pos b + neg a)
((plus (pos a) (neg c) ≶ plus (pos c) (neg a)) +
 (plus (pos c) (neg b) ≶ plus (pos b) (neg c)))%type right.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: neg c + (pos a + neg b) ≶ neg c + (pos b + neg a)
E2: pos c + neg a + neg b ≶ neg c + (pos b + neg a)
pos c + neg b ≶ pos b + neg c apply (strong_extensionality (+ (PairT.neg a))).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: neg c + (pos a + neg b) ≶ neg c + (pos b + neg a)
E2: pos c + neg a + neg b ≶ neg c + (pos b + neg a)
pos c + neg b + neg a ≶ pos b + neg c + neg a
    assert (Hrw : PairT.pos c + PairT.neg b + PairT.neg a =
      PairT.pos c + PairT.neg a + PairT.neg b)
    by ring_with_nat;rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: neg c + (pos a + neg b) ≶ neg c + (pos b + neg a)
E2: pos c + neg a + neg b ≶ neg c + (pos b + neg a)
pos c + neg a + neg b ≶ pos b + neg c + neg a
    assert (Hrw : PairT.pos b + PairT.neg c + PairT.neg a =
      PairT.neg c + (PairT.pos b + PairT.neg a))
    by ring_with_nat;rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b, c: T N
E1: neg c + (pos a + neg b) ≶ neg c + (pos b + neg a)
E2: pos c + neg a + neg b ≶ neg c + (pos b + neg a)
pos c + neg a + neg b ≶ neg c + (pos b + neg a)
    trivial.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, ~ (x ≶ y) <-> x = y apply (Z_ind2 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N, ~ (' x ≶ ' y) <-> ' x = ' y
  intros a b;rewrite Zapart_def;unfold PairT.Tapart.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: T N
~ (pos a + neg b ≶ pos b + neg a) <-> ' a = ' b
  split;intros E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: T N
E: ~ (pos a + neg b ≶ pos b + neg a)
' a = ' b
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: T N
E: ' a = ' b
~ (pos a + neg b ≶ pos b + neg a)
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: T N
E: ~ (pos a + neg b ≶ pos b + neg a)
' a = ' b apply Z_path;red.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: T N
E: ~ (pos a + neg b ≶ pos b + neg a)
pos a + neg b = pos b + neg a
    apply tight_apart,E.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: T N
E: ' a = ' b
~ (pos a + neg b ≶ pos b + neg a) apply related_path in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: T N
E: equiv a b
~ (pos a + neg b ≶ pos b + neg a) apply tight_apart,E.
Qed.

Instance Z_is_apart@{} : IsApart Z
  := ltac:(first [exact Z_is_apart'@{Ularge Ularge Ularge Ularge Ularge
                                     Ularge}|
                  exact Z_is_apart'@{}]).

Lemma Z_full_psorder' : FullPseudoOrder Zle Zlt.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
FullPseudoOrder Zle Zlt
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
FullPseudoOrder Zle Zlt
split;[apply _|split;try apply _|].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, ~ (x < y < x)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
CoTransitive lt
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, x ≶ y <-> (x < y) + (y < x)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, x ≤ y <-> ~ (y < x)
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, ~ (x < y < x) apply (Z_ind2 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N, ~ (' x < ' y < ' x)
  intros a b;rewrite !Zlt_def;unfold PairT.Tlt.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: T N
~ (pos a + neg b < pos b + neg a < pos a + neg b)
  apply pseudo_order_antisym.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
CoTransitive lt hnf.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z,
x < y -> forall z : Z, hor (x < z) (z < y) intros a b E c;revert a b c E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall a b c : Z, a < b -> hor (a < c) (c < b)
  apply (Z_ind3 (fun _ _ _ => _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : T N,
' x < ' y -> hor (' x < ' z) (' z < ' y)
  intros [pa na] [pb nb] [pc nc];rewrite !Zlt_def;unfold PairT.Tlt.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} ->
hor
  (pos {| pos := pa; neg := na |} +
   neg {| pos := pc; neg := nc |} <
   pos {| pos := pc; neg := nc |} +
   neg {| pos := pa; neg := na |})
  (pos {| pos := pc; neg := nc |} +
   neg {| pos := pb; neg := nb |} <
   pos {| pos := pb; neg := nb |} +
   neg {| pos := pc; neg := nc |})
  intros E1.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |}
hor
  (pos {| pos := pa; neg := na |} +
   neg {| pos := pc; neg := nc |} <
   pos {| pos := pc; neg := nc |} +
   neg {| pos := pa; neg := na |})
  (pos {| pos := pc; neg := nc |} +
   neg {| pos := pb; neg := nb |} <
   pos {| pos := pb; neg := nb |} +
   neg {| pos := pc; neg := nc |})
  apply (strictly_order_preserving (+ nc)) in E1.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
hor
  (pos {| pos := pa; neg := na |} +
   neg {| pos := pc; neg := nc |} <
   pos {| pos := pc; neg := nc |} +
   neg {| pos := pa; neg := na |})
  (pos {| pos := pc; neg := nc |} +
   neg {| pos := pb; neg := nb |} <
   pos {| pos := pb; neg := nb |} +
   neg {| pos := pc; neg := nc |})
  eapply (merely_destruct (cotransitive E1 _));intros [E2|E2];apply tr.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
E2: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc < 
?z
((plus (pos {| pos := pa; neg := na |})
    (neg {| pos := pc; neg := nc |}) <
  plus (pos {| pos := pc; neg := nc |})
    (neg {| pos := pa; neg := na |})) +
 (plus (pos {| pos := pc; neg := nc |})
    (neg {| pos := pb; neg := nb |}) <
  plus (pos {| pos := pb; neg := nb |})
    (neg {| pos := pc; neg := nc |})))%type
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
E2: ?z <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
((plus (pos {| pos := pa; neg := na |})
    (neg {| pos := pc; neg := nc |}) <
  plus (pos {| pos := pc; neg := nc |})
    (neg {| pos := pa; neg := na |})) +
 (plus (pos {| pos := pc; neg := nc |})
    (neg {| pos := pb; neg := nb |}) <
  plus (pos {| pos := pb; neg := nb |})
    (neg {| pos := pc; neg := nc |})))%type
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
E2: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc < 
?z
((plus (pos {| pos := pa; neg := na |})
    (neg {| pos := pc; neg := nc |}) <
  plus (pos {| pos := pc; neg := nc |})
    (neg {| pos := pa; neg := na |})) +
 (plus (pos {| pos := pc; neg := nc |})
    (neg {| pos := pb; neg := nb |}) <
  plus (pos {| pos := pb; neg := nb |})
    (neg {| pos := pc; neg := nc |})))%type left.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
E2: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc < 
?z
pos {| pos := pa; neg := na |} +
neg {| pos := pc; neg := nc |} <
pos {| pos := pc; neg := nc |} +
neg {| pos := pa; neg := na |} apply (strictly_order_reflecting ((nb) +)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
E2: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc < 
?z
nb +
(pos {| pos := pa; neg := na |} +
 neg {| pos := pc; neg := nc |}) <
nb +
(pos {| pos := pc; neg := nc |} +
 neg {| pos := pa; neg := na |})
    assert (Hrw : nb + (pa + nc) = pa + nb + nc)
    by ring_with_nat;rewrite Hrw;exact E2.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
E2: nb +
(pos {| pos := pc; neg := nc |} +
 neg {| pos := pa; neg := na |}) <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
((plus (pos {| pos := pa; neg := na |})
    (neg {| pos := pc; neg := nc |}) <
  plus (pos {| pos := pc; neg := nc |})
    (neg {| pos := pa; neg := na |})) +
 (plus (pos {| pos := pc; neg := nc |})
    (neg {| pos := pb; neg := nb |}) <
  plus (pos {| pos := pb; neg := nb |})
    (neg {| pos := pc; neg := nc |})))%type right.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
E2: nb +
(pos {| pos := pc; neg := nc |} +
 neg {| pos := pa; neg := na |}) <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
pos {| pos := pc; neg := nc |} +
neg {| pos := pb; neg := nb |} <
pos {| pos := pb; neg := nb |} +
neg {| pos := pc; neg := nc |} apply (strictly_order_reflecting ((na) +)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
E2: nb +
(pos {| pos := pc; neg := nc |} +
 neg {| pos := pa; neg := na |}) <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
na +
(pos {| pos := pc; neg := nc |} +
 neg {| pos := pb; neg := nb |}) <
na +
(pos {| pos := pb; neg := nb |} +
 neg {| pos := pc; neg := nc |})
    assert (Hrw : na + (pc + nb) = nb + (pc + na))
    by ring_with_nat;rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
E2: nb +
(pos {| pos := pc; neg := nc |} +
 neg {| pos := pa; neg := na |}) <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
nb + (pc + na) <
na +
(pos {| pos := pb; neg := nb |} +
 neg {| pos := pc; neg := nc |})
    assert (Hrw : na + (pb + nc) = pb + na + nc)
    by ring_with_nat;rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
pa, na, pb, nb, pc, nc: N
E1: pos {| pos := pa; neg := na |} +
neg {| pos := pb; neg := nb |} + nc <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
E2: nb +
(pos {| pos := pc; neg := nc |} +
 neg {| pos := pa; neg := na |}) <
pos {| pos := pb; neg := nb |} +
neg {| pos := pa; neg := na |} + nc
nb + (pc + na) < pb + na + nc
    trivial.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, x ≶ y <-> (x < y) + (y < x) apply @Z_ind2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, IsHProp (x ≶ y <-> (x < y) + (y < x))
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N,
' x ≶ ' y <-> (' x < ' y) + (' y < ' x)
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, IsHProp (x ≶ y <-> (x < y) + (y < x)) intros a b.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: Z
IsHProp (a ≶ b <-> (a < b) + (b < a))
    apply @istrunc_prod;[|apply _].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: Z
IsHProp (a ≶ b -> (a < b) + (b < a))
    apply (@istrunc_arrow _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: Z
IsHProp ((a < b) + (b < a))
    apply ishprop_sum;try exact _.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: Z
a < b -> b < a -> Empty
    intros E1 E2;apply (irreflexivity lt a).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: Z
E1: a < b
E2: b < a
a < a
    transitivity b;trivial.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N,
' x ≶ ' y <-> (' x < ' y) + (' y < ' x) intros a b;rewrite Zapart_def,!Zlt_def;unfold PairT.Tapart,PairT.Tlt.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: T N
pos a + neg b ≶ pos b + neg a <->
(pos a + neg b < pos b + neg a) +
(pos b + neg a < pos a + neg b)
    apply apart_iff_total_lt.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : Z, x ≤ y <-> ~ (y < x) apply (Z_ind2 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y : T N, ' x ≤ ' y <-> ~ (' y < ' x)
  intros a b;rewrite Zle_def,Zlt_def;unfold PairT.Tlt,PairT.Tle.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
a, b: T N
pos a + neg b ≤ pos b + neg a <->
~ (pos b + neg a < pos a + neg b)
  apply le_iff_not_lt_flip.
Qed.

(* Coq pre 8.8 produces phantom universes, see GitHub Coq/Coq#1033. *)
Instance Z_full_psorder@{} : FullPseudoOrder Zle Zlt
  := ltac:(first [exact Z_full_psorder'@{Ularge Ularge Ularge Ularge Ularge
                                                Ularge Ularge Ularge Ularge}|
                  exact Z_full_psorder'@{Ularge Ularge Ularge Ularge Ularge
                                         Ularge Ularge Ularge Ularge Ularge}|
                  exact Z_full_psorder'@{}]).

Lemma Zmult_strong_ext_l' : forall z : Z, StrongExtensionality (z *.).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall z : Z, StrongExtensionality (mult z)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall z : Z, StrongExtensionality (mult z)
red;apply (Z_ind3 (fun _ _ _ => _ -> _)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall x y z : T N, ' x * ' y ≶ ' x * ' z -> ' y ≶ ' z
intros [zp zn] [xp xn] [yp yn];rewrite !Zapart_def;unfold PairT.Tapart;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp) ->
xp + yn ≶ yp + xn
intros E1.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
xp + yn ≶ yp + xn
refine (merely_destruct (strong_binary_extensionality (+)
     (zp * (xp + yn)) (zn * (yp + xn)) (zp * (yp + xn)) (zn * (xp + yn)) _) _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
zp * (xp + yn) + zn * (yp + xn)
≶ zp * (yp + xn) + zn * (xp + yn)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
(zp * (xp + yn) ≶ zp * (yp + xn)) +
(zn * (yp + xn) ≶ zn * (xp + yn)) -> 
xp + yn ≶ yp + xn
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
zp * (xp + yn) + zn * (yp + xn)
≶ zp * (yp + xn) + zn * (xp + yn) assert (Hrw : zp * (xp + yn) + zn * (yp + xn)
  = zp * xp + zn * xn + (zp * yn + zn * yp))
  by ring_with_nat;rewrite Hrw;clear Hrw.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * (yp + xn) + zn * (xp + yn)
  assert (Hrw : zp * (yp + xn) + zn * (xp + yn)
  = zp * yp + zn * yn + (zp * xn + zn * xp))
  by ring_with_nat;rewrite Hrw;exact E1.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
(zp * (xp + yn) ≶ zp * (yp + xn)) +
(zn * (yp + xn) ≶ zn * (xp + yn)) -> xp + yn ≶ yp + xn intros [E2|E2].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
E2: zp * (xp + yn) ≶ zp * (yp + xn)
xp + yn ≶ yp + xn
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
E2: zn * (yp + xn) ≶ zn * (xp + yn)
xp + yn ≶ yp + xn
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
E2: zp * (xp + yn) ≶ zp * (yp + xn)
xp + yn ≶ yp + xn apply (strong_extensionality (zp *.)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
E2: zp * (xp + yn) ≶ zp * (yp + xn)
zp * (xp + yn) ≶ zp * (yp + xn)
    trivial.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
E2: zn * (yp + xn) ≶ zn * (xp + yn)
xp + yn ≶ yp + xn apply symmetry;apply (strong_extensionality (zn *.)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
zp, zn, xp, xn, yp, yn: N
E1: zp * xp + zn * xn + (zp * yn + zn * yp)
≶ zp * yp + zn * yn + (zp * xn + zn * xp)
E2: zn * (yp + xn) ≶ zn * (xp + yn)
zn * (yp + xn) ≶ zn * (xp + yn)
    trivial.
Qed.

Instance Zmult_strong_ext_l@{} : forall z : Z, StrongExtensionality (z *.)
  := ltac:(first [exact Zmult_strong_ext_l'@{Ularge Ularge}|
                  exact Zmult_strong_ext_l'@{}]).

Instance Z_full_pseudo_srorder@{}
  : FullPseudoSemiRingOrder Zle Zlt.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
FullPseudoSemiRingOrder Zle Zlt
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
FullPseudoSemiRingOrder Zle Zlt
pose proof Z_ring.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
X: IsCRing Z
FullPseudoSemiRingOrder Zle Zlt
first [apply from_full_pseudo_ring_order@{UN UN UN UN UN UN UN Ularge}|
       apply from_full_pseudo_ring_order]; try exact _.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
X: IsCRing Z
StrongBinaryExtensionality mult
exact apartness.strong_binary_setoid_morphism_commutative.
Qed.

Goal FullPseudoSemiRingOrder Zle Zlt.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
FullPseudoSemiRingOrder Zle Zlt
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
FullPseudoSemiRingOrder Zle Zlt
Fail exact Z_full_pseudo_srorder@{i}.The command has indeed failed with message:
Universe instance length is 1 but should be 0.
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
FullPseudoSemiRingOrder Zle Zlt
Abort.

#[export] Instance Z_to_ring@{} : IntegersToRing@{UN UNalt} Z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IntegersToRing Z
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IntegersToRing Z
red.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall (R : Type) (Aplus : Plus R) (Amult : Mult R)
(Azero : Zero R) (Aone : One R) (Anegate : Negate R),
IsCRing R -> Z -> R intros R ??????.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
R: Type
Aplus0: Plus R
Amult0: Mult R
Azero0: Zero R
Aone0: One R
Anegate: Negate R
H2: IsCRing R
Z -> R
eapply Z_rec.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
R: Type
Aplus0: Plus R
Amult0: Mult R
Azero0: Zero R
Aone0: One R
Anegate: Negate R
H2: IsCRing R
forall x y : T N, equiv x y -> ?dclass x = ?dclass y
exact (PairT.to_ring_respects N).
Defined.

Lemma Z_to_ring_morphism' `{IsCRing B} : IsSemiRingPreserving (integers_to_ring Z B).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
IsSemiRingPreserving (integers_to_ring Z B)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
IsSemiRingPreserving (integers_to_ring Z B)
split;split;red.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
forall x y : Z,
integers_to_ring Z B (sg_op x y) =
sg_op (integers_to_ring Z B x)
  (integers_to_ring Z B y)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
integers_to_ring Z B mon_unit = mon_unit
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
forall x y : Z,
integers_to_ring Z B (sg_op x y) =
sg_op (integers_to_ring Z B x)
  (integers_to_ring Z B y)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
integers_to_ring Z B mon_unit = mon_unit
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
forall x y : Z,
integers_to_ring Z B (sg_op x y) =
sg_op (integers_to_ring Z B x)
  (integers_to_ring Z B y) change (@sg_op B _) with (@plus B _);
  change (@sg_op Z _) with (@plus Z _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
forall x y : Z,
integers_to_ring Z B (x + y) =
integers_to_ring Z B x + integers_to_ring Z B y
  apply (Z_ind2 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
forall x y : T N,
integers_to_ring Z B (' x + ' y) =
integers_to_ring Z B (' x) +
integers_to_ring Z B (' y)
  intros [pa na] [pb nb].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
integers_to_ring Z B
  (' {| pos := pa; neg := na |} +
   ' {| pos := pb; neg := nb |}) =
integers_to_ring Z B (' {| pos := pa; neg := na |}) +
integers_to_ring Z B (' {| pos := pb; neg := nb |})
  unfold integers_to_ring;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
naturals_to_semiring N B (pa + pb) -
naturals_to_semiring N B (na + nb) =
naturals_to_semiring N B pa -
naturals_to_semiring N B na +
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
  rewrite !(preserves_plus (f:=naturals_to_semiring N B)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
naturals_to_semiring N B pa +
naturals_to_semiring N B pb -
(naturals_to_semiring N B na +
 naturals_to_semiring N B nb) =
naturals_to_semiring N B pa -
naturals_to_semiring N B na +
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
  rewrite negate_plus_distr.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
naturals_to_semiring N B pa +
naturals_to_semiring N B pb +
(- naturals_to_semiring N B na -
 naturals_to_semiring N B nb) =
naturals_to_semiring N B pa -
naturals_to_semiring N B na +
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb) ring_with_nat.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
integers_to_ring Z B mon_unit = mon_unit change (@mon_unit B _) with (@zero B _);
  change (@mon_unit Z _) with (@zero Z _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
integers_to_ring Z B 0 = 0
  unfold integers_to_ring;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
naturals_to_semiring N B 0 -
naturals_to_semiring N B 0 = 0
  rewrite (preserves_0 (f:=naturals_to_semiring N B)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
0 - 0 = 0
  rewrite negate_0,plus_0_r;trivial.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
forall x y : Z,
integers_to_ring Z B (sg_op x y) =
sg_op (integers_to_ring Z B x)
  (integers_to_ring Z B y) change (@sg_op B _) with (@mult B _);
  change (@sg_op Z _) with (@mult Z _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
forall x y : Z,
integers_to_ring Z B (x * y) =
integers_to_ring Z B x * integers_to_ring Z B y
  apply (Z_ind2 _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
forall x y : T N,
integers_to_ring Z B (' x * ' y) =
integers_to_ring Z B (' x) *
integers_to_ring Z B (' y)
  intros [pa na] [pb nb].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
integers_to_ring Z B
  (' {| pos := pa; neg := na |} *
   ' {| pos := pb; neg := nb |}) =
integers_to_ring Z B (' {| pos := pa; neg := na |}) *
integers_to_ring Z B (' {| pos := pb; neg := nb |})
  unfold integers_to_ring;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
naturals_to_semiring N B (pa * pb + na * nb) -
naturals_to_semiring N B (pa * nb + na * pb) =
(naturals_to_semiring N B pa -
 naturals_to_semiring N B na) *
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
  rewrite !(preserves_plus (f:=naturals_to_semiring N B)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
naturals_to_semiring N B (pa * pb) +
naturals_to_semiring N B (na * nb) -
naturals_to_semiring N B (pa * nb + na * pb) =
(naturals_to_semiring N B pa -
 naturals_to_semiring N B na) *
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
  rewrite !(preserves_mult (f:=naturals_to_semiring N B)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
naturals_to_semiring N B pa *
naturals_to_semiring N B pb +
naturals_to_semiring N B na *
naturals_to_semiring N B nb -
naturals_to_semiring N B (pa * nb + na * pb) =
(naturals_to_semiring N B pa -
 naturals_to_semiring N B na) *
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
  rewrite (preserves_plus (f:=naturals_to_semiring N B)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
naturals_to_semiring N B pa *
naturals_to_semiring N B pb +
naturals_to_semiring N B na *
naturals_to_semiring N B nb -
(naturals_to_semiring N B (pa * nb) +
 naturals_to_semiring N B (na * pb)) =
(naturals_to_semiring N B pa -
 naturals_to_semiring N B na) *
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
  rewrite !(preserves_mult (f:=naturals_to_semiring N B)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
naturals_to_semiring N B pa *
naturals_to_semiring N B pb +
naturals_to_semiring N B na *
naturals_to_semiring N B nb -
(naturals_to_semiring N B pa *
 naturals_to_semiring N B nb +
 naturals_to_semiring N B na *
 naturals_to_semiring N B pb) =
(naturals_to_semiring N B pa -
 naturals_to_semiring N B na) *
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
  rewrite negate_plus_distr.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
naturals_to_semiring N B pa *
naturals_to_semiring N B pb +
naturals_to_semiring N B na *
naturals_to_semiring N B nb +
(-
 (naturals_to_semiring N B pa *
  naturals_to_semiring N B nb) -
 naturals_to_semiring N B na *
 naturals_to_semiring N B pb) =
(naturals_to_semiring N B pa -
 naturals_to_semiring N B na) *
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
  rewrite negate_mult_distr_r,negate_mult_distr_l.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
naturals_to_semiring N B pa *
naturals_to_semiring N B pb +
naturals_to_semiring N B na *
naturals_to_semiring N B nb +
(naturals_to_semiring N B pa *
 - naturals_to_semiring N B nb +
 - naturals_to_semiring N B na *
 naturals_to_semiring N B pb) =
(naturals_to_semiring N B pa -
 naturals_to_semiring N B na) *
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
  rewrite <-(negate_mult_negate (naturals_to_semiring N B na)
    (naturals_to_semiring N B nb)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
pa, na, pb, nb: N
naturals_to_semiring N B pa *
naturals_to_semiring N B pb +
- naturals_to_semiring N B na *
- naturals_to_semiring N B nb +
(naturals_to_semiring N B pa *
 - naturals_to_semiring N B nb +
 - naturals_to_semiring N B na *
 naturals_to_semiring N B pb) =
(naturals_to_semiring N B pa -
 naturals_to_semiring N B na) *
(naturals_to_semiring N B pb -
 naturals_to_semiring N B nb)
  ring_with_nat.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
integers_to_ring Z B mon_unit = mon_unit change (@mon_unit B _) with (@one B _);
  change (@mon_unit Z _) with (@one Z _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
integers_to_ring Z B 1 = 1
  unfold integers_to_ring;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
naturals_to_semiring N B 1 -
naturals_to_semiring N B 0 = 1
  rewrite (preserves_1 (f:=naturals_to_semiring N B)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
1 - naturals_to_semiring N B 0 = 1
  rewrite (preserves_0 (f:=naturals_to_semiring N B)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
1 - 0 = 1
  rewrite negate_0,plus_0_r;trivial.
Qed.

Instance Z_to_ring_morphism@{} `{IsCRing B} : IsSemiRingPreserving (integers_to_ring Z B)
  := ltac:(first [exact Z_to_ring_morphism'@{Ularge}|
                  exact Z_to_ring_morphism'@{}]).

Lemma Z_to_ring_unique@{} `{IsCRing B} (h : Z -> B) `{!IsSemiRingPreserving h}
  : forall x : Z, integers_to_ring Z B x = h x.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
h: Z -> B
IsSemiRingPreserving0: IsSemiRingPreserving h
forall x : Z, integers_to_ring Z B x = h x
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
h: Z -> B
IsSemiRingPreserving0: IsSemiRingPreserving h
forall x : Z, integers_to_ring Z B x = h x
pose proof Z_ring.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
h: Z -> B
IsSemiRingPreserving0: IsSemiRingPreserving h
X: IsCRing Z
forall x : Z, integers_to_ring Z B x = h x
apply (Z_ind _).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
h: Z -> B
IsSemiRingPreserving0: IsSemiRingPreserving h
X: IsCRing Z
forall x : T N, integers_to_ring Z B (' x) = h (' x)
intros [pa na];unfold integers_to_ring;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
h: Z -> B
IsSemiRingPreserving0: IsSemiRingPreserving h
X: IsCRing Z
pa, na: N
naturals_to_semiring N B pa -
naturals_to_semiring N B na =
h (' {| pos := pa; neg := na |})
rewrite Npair_splits.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
h: Z -> B
IsSemiRingPreserving0: IsSemiRingPreserving h
X: IsCRing Z
pa, na: N
naturals_to_semiring N B pa -
naturals_to_semiring N B na = h (' pa - ' na)
rewrite (preserves_plus (f:=h)),(preserves_negate (f:=h)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
h: Z -> B
IsSemiRingPreserving0: IsSemiRingPreserving h
X: IsCRing Z
pa, na: N
naturals_to_semiring N B pa -
naturals_to_semiring N B na = h (' pa) - h (' na)
change (h (' pa)) with (Compose h (cast N Z) pa).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
h: Z -> B
IsSemiRingPreserving0: IsSemiRingPreserving h
X: IsCRing Z
pa, na: N
naturals_to_semiring N B pa -
naturals_to_semiring N B na =
(h ∘ cast N Z) pa - h (' na)
change (h (' na)) with (Compose h (cast N Z) na).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
h: Z -> B
IsSemiRingPreserving0: IsSemiRingPreserving h
X: IsCRing Z
pa, na: N
naturals_to_semiring N B pa -
naturals_to_semiring N B na =
(h ∘ cast N Z) pa - (h ∘ cast N Z) na
rewrite 2!(naturals_initial (h:=Compose h (cast N Z))).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
B: Type
Aplus0: Plus B
Amult0: Mult B
Azero0: Zero B
Aone0: One B
Anegate: Negate B
H2: IsCRing B
h: Z -> B
IsSemiRingPreserving0: IsSemiRingPreserving h
X: IsCRing Z
pa, na: N
(h ∘ cast N Z) pa - (h ∘ cast N Z) na =
(h ∘ cast N Z) pa - (h ∘ cast N Z) na
trivial.
Qed.

#[export] Instance Z_integers@{} : Integers Z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Integers Z
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
Integers Z
split;try exact _.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsCRing Z
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall (B : Type) (Aplus0 : Plus B) 
(Amult0 : Mult B) (Azero0 : Zero B) 
(Aone0 : One B) (Anegate0 : Negate B) 
(H : IsCRing B) (h : Z -> B),
IsSemiRingPreserving h ->
forall x : Z, integers_to_ring Z B x = h x
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
IsCRing Z exact Z_ring.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
forall (B : Type) (Aplus0 : Plus B) (Amult0 : Mult B)
(Azero0 : Zero B) (Aone0 : One B)
(Anegate0 : Negate B) (H : IsCRing B) (h : Z -> B),
IsSemiRingPreserving h ->
forall x : Z, integers_to_ring Z B x = h x exact @Z_to_ring_unique.
Qed.

Context `{!NatDistance N}.

Lemma Z_abs_aux_0@{} : forall a b z : N, a + z = b -> z = 0 ->
  naturals_to_semiring N Z 0 = ' {| PairT.pos := a; PairT.neg := b |}.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall a b z : N,
a + z = b ->
z = 0 ->
naturals_to_semiring N Z 0 =
' {| pos := a; neg := b |}
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall a b z : N,
a + z = b ->
z = 0 ->
naturals_to_semiring N Z 0 =
' {| pos := a; neg := b |}
intros a b z E E'.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
E': z = 0
naturals_to_semiring N Z 0 =
' {| pos := a; neg := b |}
rewrite (preserves_0 (A:=N)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
E': z = 0
0 = ' {| pos := a; neg := b |}
rewrite E',plus_0_r in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a = b
E': z = 0
0 = ' {| pos := a; neg := b |} rewrite E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a = b
E': z = 0
0 = ' {| pos := b; neg := b |}
apply Z_path.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a = b
E': z = 0
equiv (inject N 0) {| pos := b; neg := b |} red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a = b
E': z = 0
0 + b = b + 0 apply plus_comm.
Qed.

Lemma Z_abs_aux_neg@{} : forall a b z : N, a + z = b ->
  naturals_to_semiring N Z z = - ' {| PairT.pos := a; PairT.neg := b |}.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall a b z : N,
a + z = b ->
naturals_to_semiring N Z z =
- ' {| pos := a; neg := b |}
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall a b z : N,
a + z = b ->
naturals_to_semiring N Z z =
- ' {| pos := a; neg := b |}
intros a b z E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
naturals_to_semiring N Z z =
- ' {| pos := a; neg := b |}
rewrite <-(naturals.to_semiring_unique (cast N Z)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
' z = - ' {| pos := a; neg := b |}
apply Z_path.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
equiv (inject N z) (opp N {| pos := a; neg := b |}) red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
z + a = b + 0 rewrite plus_0_r,plus_comm;trivial.
Qed.

Lemma Z_abs_aux_pos@{} : forall a b z : N, b + z = a ->
  naturals_to_semiring N Z z = ' {| PairT.pos := a; PairT.neg := b |}.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall a b z : N,
b + z = a ->
naturals_to_semiring N Z z =
' {| pos := a; neg := b |}
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall a b z : N,
b + z = a ->
naturals_to_semiring N Z z =
' {| pos := a; neg := b |}
intros a b z E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: b + z = a
naturals_to_semiring N Z z =
' {| pos := a; neg := b |}
rewrite <-(naturals.to_semiring_unique (cast N Z)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: b + z = a
' z = ' {| pos := a; neg := b |}
apply Z_path;red;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: b + z = a
z + b = a + 0 rewrite plus_0_r,plus_comm;trivial.
Qed.

(* We use decidability of equality on N
   to make sure we always go left when the inputs are equal.
   Otherwise we would have to truncate IntAbs. *)
Definition Z_abs_def@{} : forall x : PairT.T N,
  (exists n : N, naturals_to_semiring N Z n = ' x)
  |_| (exists n : N, naturals_to_semiring N Z n = - ' x).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall x : T N,
{n : N & naturals_to_semiring N Z n = ' x} +
{n : N & naturals_to_semiring N Z n = - ' x}
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall x : T N,
{n : N & naturals_to_semiring N Z n = ' x} +
{n : N & naturals_to_semiring N Z n = - ' x}
intros [a b].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b: N
({n : N &
 naturals_to_semiring N Z n =
 ' {| pos := a; neg := b |}} +
 {n : N &
 naturals_to_semiring N Z n =
 - ' {| pos := a; neg := b |}})%type
destruct (nat_distance_sig a b) as [[z E]|[z E]].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
({n : N &
 naturals_to_semiring N Z n =
 ' {| pos := a; neg := b |}} +
 {n : N &
 naturals_to_semiring N Z n =
 - ' {| pos := a; neg := b |}})%type
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: b + z = a
({n : N &
 naturals_to_semiring N Z n =
 ' {| pos := a; neg := b |}} +
 {n : N &
 naturals_to_semiring N Z n =
 - ' {| pos := a; neg := b |}})%type
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
({n : N &
 naturals_to_semiring N Z n =
 ' {| pos := a; neg := b |}} +
 {n : N &
 naturals_to_semiring N Z n =
 - ' {| pos := a; neg := b |}})%type destruct (dec (z = 0)) as [E'|_].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
E': z = 0
({n : N &
 naturals_to_semiring N Z n =
 ' {| pos := a; neg := b |}} +
 {n : N &
 naturals_to_semiring N Z n =
 - ' {| pos := a; neg := b |}})%type
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
({n : N &
 naturals_to_semiring N Z n =
 ' {| pos := a; neg := b |}} +
 {n : N &
 naturals_to_semiring N Z n =
 - ' {| pos := a; neg := b |}})%type
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
E': z = 0
({n : N &
 naturals_to_semiring N Z n =
 ' {| pos := a; neg := b |}} +
 {n : N &
 naturals_to_semiring N Z n =
 - ' {| pos := a; neg := b |}})%type left.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
E': z = 0
{n : N &
naturals_to_semiring N Z n =
' {| pos := a; neg := b |}} exists 0.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
E': z = 0
naturals_to_semiring N Z 0 =
' {| pos := a; neg := b |} apply Z_abs_aux_0 with z;trivial.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
({n : N &
 naturals_to_semiring N Z n =
 ' {| pos := a; neg := b |}} +
 {n : N &
 naturals_to_semiring N Z n =
 - ' {| pos := a; neg := b |}})%type right.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
{n : N &
naturals_to_semiring N Z n =
- ' {| pos := a; neg := b |}} exists z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: a + z = b
naturals_to_semiring N Z z =
- ' {| pos := a; neg := b |} apply Z_abs_aux_neg;trivial.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: b + z = a
({n : N &
 naturals_to_semiring N Z n =
 ' {| pos := a; neg := b |}} +
 {n : N &
 naturals_to_semiring N Z n =
 - ' {| pos := a; neg := b |}})%type left.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: b + z = a
{n : N &
naturals_to_semiring N Z n =
' {| pos := a; neg := b |}} exists z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b, z: N
E: b + z = a
naturals_to_semiring N Z z =
' {| pos := a; neg := b |} apply Z_abs_aux_pos;trivial.
Defined.

Lemma Z_abs_respects' : forall (x y : PairT.T N) (E : PairT.equiv x y),
  transport
    (fun q : Z =>
     (exists n : N, naturals_to_semiring N Z n = q)
     |_| (exists n : N, naturals_to_semiring N Z n = - q)) (Z_path E) (Z_abs_def x)
  = Z_abs_def y.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall (x y : T N) (E : equiv x y),
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E) (Z_abs_def x) = Z_abs_def y
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall (x y : T N) (E : equiv x y),
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E) (Z_abs_def x) = Z_abs_def y
intros [pa pb] [na nb] E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: equiv {| pos := pa; neg := pb |}
  {| pos := na; neg := nb |}
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E) (Z_abs_def {| pos := pa; neg := pb |}) =
Z_abs_def {| pos := na; neg := nb |}
red in E; simpl in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E) (Z_abs_def {| pos := pa; neg := pb |}) =
Z_abs_def {| pos := na; neg := nb |}
unfold Z_abs_def.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E)
  match nat_distance_sig pa pb with
  | inl s =>
      match dec (s.1 = 0) with
      | inl p => inl (0; Z_abs_aux_0 pa pb s.1 s.2 p)
      | inr _ =>
          inr (s.1; Z_abs_aux_neg pa pb s.1 s.2)
      end
  | inr s => inl (s.1; Z_abs_aux_pos pa pb s.1 s.2)
  end =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end
destruct (nat_distance_sig pa pb) as [[z1 E1] | [z1 E1]];simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E)
  match dec (z1 = 0) with
  | inl p => inl (0; Z_abs_aux_0 pa pb z1 E1 p)
  | inr _ => inr (z1; Z_abs_aux_neg pa pb z1 E1)
  end =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E) (inl (z1; Z_abs_aux_pos pa pb z1 E1)) =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E)
  match dec (z1 = 0) with
  | inl p => inl (0; Z_abs_aux_0 pa pb z1 E1 p)
  | inr _ => inr (z1; Z_abs_aux_neg pa pb z1 E1)
  end =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end destruct (dec (z1 = 0)) as [E2 | E2].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E) (inl (0; Z_abs_aux_0 pa pb z1 E1 E2)) =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E) (inr (z1; Z_abs_aux_neg pa pb z1 E1)) =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E) (inl (0; Z_abs_aux_0 pa pb z1 E1 E2)) =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end rewrite Sum.transport_sum.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
inl
  (transport
     (fun a : Z =>
      {n : N & naturals_to_semiring N Z n = a})
     (Z_path E) (0; Z_abs_aux_0 pa pb z1 E1 E2)) =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end rewrite Sigma.transport_sigma.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
inl
  (transport (fun _ : Z => N) (Z_path E)
     (0; Z_abs_aux_0 pa pb z1 E1 E2).1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) (Z_path E)
    (0; Z_abs_aux_0 pa pb z1 E1 E2).1
    (0; Z_abs_aux_0 pa pb z1 E1 E2).2) =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end
    destruct (nat_distance_sig na nb) as [[z2 E3] | [z2 E3]];
    [destruct (dec (z2 = 0)) as [E4 | E4]|];simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: na + z2 = nb
E4: z2 = 0
inl
  (transport (fun _ : Z => N) (Z_path E) 0;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) (Z_path E) 0
    (Z_abs_aux_0 pa pb z1 E1 E2)) =
inl (0; Z_abs_aux_0 na nb z2 E3 E4)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: na + z2 = nb
E4: z2 <> 0
inl
  (transport (fun _ : Z => N) (Z_path E) 0;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) 
    (Z_path E) 0 (Z_abs_aux_0 pa pb z1 E1 E2)) =
inr (z2; Z_abs_aux_neg na nb z2 E3)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: nb + z2 = na
inl
  (transport (fun _ : Z => N) (Z_path E) 0;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) 
    (Z_path E) 0 (Z_abs_aux_0 pa pb z1 E1 E2)) =
inl (z2; Z_abs_aux_pos na nb z2 E3)
    *H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: na + z2 = nb
E4: z2 = 0
inl
  (transport (fun _ : Z => N) (Z_path E) 0;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) (Z_path E) 0
    (Z_abs_aux_0 pa pb z1 E1 E2)) =
inl (0; Z_abs_aux_0 na nb z2 E3 E4) apply ap.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: na + z2 = nb
E4: z2 = 0
(transport (fun _ : Z => N) (Z_path E) 0;
transportD (fun _ : Z => N)
  (fun (x : Z) (y : N) =>
   naturals_to_semiring N Z y = x) (Z_path E) 0
  (Z_abs_aux_0 pa pb z1 E1 E2)) =
(0; Z_abs_aux_0 na nb z2 E3 E4)
      apply Sigma.path_sigma_hprop;simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: na + z2 = nb
E4: z2 = 0
transport (fun _ : Z => N) (Z_path E) 0 = 0
      apply PathGroupoids.transport_const.
    *H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: na + z2 = nb
E4: z2 <> 0
inl
  (transport (fun _ : Z => N) (Z_path E) 0;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) (Z_path E) 0
    (Z_abs_aux_0 pa pb z1 E1 E2)) =
inr (z2; Z_abs_aux_neg na nb z2 E3) destruct E4.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: na + z2 = nb
z2 = 0
      rewrite <-E1,<-E3,E2,plus_0_r,<-(plus_0_r (na+pa)) in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pa + (na + z2) = na + pa + 0
E1: pa + z1 = pb
E2: z1 = 0
E3: na + z2 = nb
z2 = 0
      rewrite plus_assoc,(plus_comm pa) in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: na + pa + z2 = na + pa + 0
E1: pa + z1 = pb
E2: z1 = 0
E3: na + z2 = nb
z2 = 0
      apply (left_cancellation plus _) in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: z2 = 0
E1: pa + z1 = pb
E2: z1 = 0
E3: na + z2 = nb
z2 = 0 trivial.
    *H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: nb + z2 = na
inl
  (transport (fun _ : Z => N) (Z_path E) 0;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) (Z_path E) 0
    (Z_abs_aux_0 pa pb z1 E1 E2)) =
inl (z2; Z_abs_aux_pos na nb z2 E3) apply ap.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: nb + z2 = na
(transport (fun _ : Z => N) (Z_path E) 0;
transportD (fun _ : Z => N)
  (fun (x : Z) (y : N) =>
   naturals_to_semiring N Z y = x) (Z_path E) 0
  (Z_abs_aux_0 pa pb z1 E1 E2)) =
(z2; Z_abs_aux_pos na nb z2 E3) apply Sigma.path_sigma_hprop.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: nb + z2 = na
(transport (fun _ : Z => N) (Z_path E) 0;
transportD (fun _ : Z => N)
  (fun (x : Z) (y : N) =>
   naturals_to_semiring N Z y = x) (Z_path E) 0
  (Z_abs_aux_0 pa pb z1 E1 E2)).1 =
(z2; Z_abs_aux_pos na nb z2 E3).1 simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: nb + z2 = na
transport (fun _ : Z => N) (Z_path E) 0 = z2
      rewrite PathGroupoids.transport_const.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 = 0
z2: N
E3: nb + z2 = na
0 = z2
      rewrite E2,plus_0_r in E1.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa = pb
E2: z1 = 0
z2: N
E3: nb + z2 = na
0 = z2
      rewrite <-E3,E1 in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z2: N
E: pb + nb = nb + z2 + pb
z1: N
E1: pa = pb
E2: z1 = 0
E3: nb + z2 = na
0 = z2
      apply (left_cancellation plus (pb + nb)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z2: N
E: pb + nb = nb + z2 + pb
z1: N
E1: pa = pb
E2: z1 = 0
E3: nb + z2 = na
pb + nb + 0 = pb + nb + z2
      rewrite plus_0_r.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z2: N
E: pb + nb = nb + z2 + pb
z1: N
E1: pa = pb
E2: z1 = 0
E3: nb + z2 = na
pb + nb = pb + nb + z2 etransitivity;[exact E|].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z2: N
E: pb + nb = nb + z2 + pb
z1: N
E1: pa = pb
E2: z1 = 0
E3: nb + z2 = na
nb + z2 + pb = pb + nb + z2
      ring_with_nat.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E) (inr (z1; Z_abs_aux_neg pa pb z1 E1)) =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end rewrite Sum.transport_sum,Sigma.transport_sigma.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
inr
  (transport (fun _ : Z => N) (Z_path E)
     (z1; Z_abs_aux_neg pa pb z1 E1).1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = - x) (Z_path E)
    (z1; Z_abs_aux_neg pa pb z1 E1).1
    (z1; Z_abs_aux_neg pa pb z1 E1).2) =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end
    destruct (nat_distance_sig na nb) as [[z2 E3] | [z2 E3]];
    [destruct (dec (z2 = 0)) as [E4 | E4]|];simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
z2: N
E3: na + z2 = nb
E4: z2 = 0
inr
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = - x) (Z_path E) z1
    (Z_abs_aux_neg pa pb z1 E1)) =
inl (0; Z_abs_aux_0 na nb z2 E3 E4)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
z2: N
E3: na + z2 = nb
E4: z2 <> 0
inr
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = - x) 
    (Z_path E) z1 (Z_abs_aux_neg pa pb z1 E1)) =
inr (z2; Z_abs_aux_neg na nb z2 E3)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
z2: N
E3: nb + z2 = na
inr
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = - x) 
    (Z_path E) z1 (Z_abs_aux_neg pa pb z1 E1)) =
inl (z2; Z_abs_aux_pos na nb z2 E3)
    *H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
z2: N
E3: na + z2 = nb
E4: z2 = 0
inr
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = - x) (Z_path E) z1
    (Z_abs_aux_neg pa pb z1 E1)) =
inl (0; Z_abs_aux_0 na nb z2 E3 E4) destruct E2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
z2: N
E3: na + z2 = nb
E4: z2 = 0
z1 = 0
      rewrite E4,plus_0_r in E3;rewrite <-E1,<-E3 in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1: N
E: pa + na = na + (pa + z1)
E1: pa + z1 = pb
z2: N
E3: na = nb
E4: z2 = 0
z1 = 0
      apply (left_cancellation plus (pa+na)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1: N
E: pa + na = na + (pa + z1)
E1: pa + z1 = pb
z2: N
E3: na = nb
E4: z2 = 0
pa + na + z1 = pa + na + 0
      rewrite (plus_comm pa na),plus_0_r,<-plus_assoc.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1: N
E: pa + na = na + (pa + z1)
E1: pa + z1 = pb
z2: N
E3: na = nb
E4: z2 = 0
na + (pa + z1) = na + pa
      rewrite (plus_comm na pa).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1: N
E: pa + na = na + (pa + z1)
E1: pa + z1 = pb
z2: N
E3: na = nb
E4: z2 = 0
na + (pa + z1) = pa + na symmetry;trivial.
    *H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
z2: N
E3: na + z2 = nb
E4: z2 <> 0
inr
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = - x) (Z_path E) z1
    (Z_abs_aux_neg pa pb z1 E1)) =
inr (z2; Z_abs_aux_neg na nb z2 E3) apply ap.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
z2: N
E3: na + z2 = nb
E4: z2 <> 0
(transport (fun _ : Z => N) (Z_path E) z1;
transportD (fun _ : Z => N)
  (fun (x : Z) (y : N) =>
   naturals_to_semiring N Z y = - x) (Z_path E) z1
  (Z_abs_aux_neg pa pb z1 E1)) =
(z2; Z_abs_aux_neg na nb z2 E3) apply Sigma.path_sigma_hprop.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
z2: N
E3: na + z2 = nb
E4: z2 <> 0
(transport (fun _ : Z => N) (Z_path E) z1;
transportD (fun _ : Z => N)
  (fun (x : Z) (y : N) =>
   naturals_to_semiring N Z y = - x) (Z_path E) z1
  (Z_abs_aux_neg pa pb z1 E1)).1 =
(z2; Z_abs_aux_neg na nb z2 E3).1
      simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
z2: N
E3: na + z2 = nb
E4: z2 <> 0
transport (fun _ : Z => N) (Z_path E) z1 = z2 rewrite PathGroupoids.transport_const.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
z2: N
E3: na + z2 = nb
E4: z2 <> 0
z1 = z2
      rewrite <-E1,<-E3 in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pa + (na + z2) = na + (pa + z1)
E1: pa + z1 = pb
E2: z1 <> 0
E3: na + z2 = nb
E4: z2 <> 0
z1 = z2
      apply (left_cancellation plus (pa + na)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pa + (na + z2) = na + (pa + z1)
E1: pa + z1 = pb
E2: z1 <> 0
E3: na + z2 = nb
E4: z2 <> 0
pa + na + z1 = pa + na + z2
      rewrite <-(plus_assoc pa na z2),(plus_comm pa na),<-plus_assoc.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pa + (na + z2) = na + (pa + z1)
E1: pa + z1 = pb
E2: z1 <> 0
E3: na + z2 = nb
E4: z2 <> 0
na + (pa + z1) = pa + (na + z2)
      symmetry;trivial.
    *H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
E2: z1 <> 0
z2: N
E3: nb + z2 = na
inr
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = - x) (Z_path E) z1
    (Z_abs_aux_neg pa pb z1 E1)) =
inl (z2; Z_abs_aux_pos na nb z2 E3) destruct E2.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pa + z1 = pb
z2: N
E3: nb + z2 = na
z1 = 0
      rewrite <-E1,<-E3 in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pa + nb = nb + z2 + (pa + z1)
E1: pa + z1 = pb
E3: nb + z2 = na
z1 = 0
      assert (Erw : nb + z2 + (pa + z1) = (pa + nb) + (z2 + z1))
      by ring_with_nat.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pa + nb = nb + z2 + (pa + z1)
E1: pa + z1 = pb
E3: nb + z2 = na
Erw: nb + z2 + (pa + z1) = pa + nb + (z2 + z1)
z1 = 0
      rewrite <-(plus_0_r (pa+nb)),Erw in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pa + nb + 0 = pa + nb + (z2 + z1)
E1: pa + z1 = pb
E3: nb + z2 = na
Erw: nb + z2 + (pa + z1) = pa + nb + (z2 + z1)
z1 = 0
      apply (left_cancellation plus _),symmetry,naturals.zero_sum in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: ((z2 = 0) * (z1 = 0))%type
E1: pa + z1 = pb
E3: nb + z2 = na
Erw: nb + z2 + (pa + z1) = pa + nb + (z2 + z1)
z1 = 0
      apply E.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E) (inl (z1; Z_abs_aux_pos pa pb z1 E1)) =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end rewrite Sum.transport_sum,Sigma.transport_sigma.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
inl
  (transport (fun _ : Z => N) (Z_path E)
     (z1; Z_abs_aux_pos pa pb z1 E1).1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) (Z_path E)
    (z1; Z_abs_aux_pos pa pb z1 E1).1
    (z1; Z_abs_aux_pos pa pb z1 E1).2) =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
inl
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) (Z_path E) z1
    (Z_abs_aux_pos pa pb z1 E1)) =
match nat_distance_sig na nb with
| inl s =>
    match dec (s.1 = 0) with
    | inl p => inl (0; Z_abs_aux_0 na nb s.1 s.2 p)
    | inr _ => inr (s.1; Z_abs_aux_neg na nb s.1 s.2)
    end
| inr s => inl (s.1; Z_abs_aux_pos na nb s.1 s.2)
end
  destruct (nat_distance_sig na nb) as [[z2 E3] | [z2 E3]];
  [destruct (dec (z2 = 0)) as [E4 | E4]|];simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: na + z2 = nb
E4: z2 = 0
inl
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) (Z_path E) z1
    (Z_abs_aux_pos pa pb z1 E1)) =
inl (0; Z_abs_aux_0 na nb z2 E3 E4)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: na + z2 = nb
E4: z2 <> 0
inl
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) 
    (Z_path E) z1 (Z_abs_aux_pos pa pb z1 E1)) =
inr (z2; Z_abs_aux_neg na nb z2 E3)
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: nb + z2 = na
inl
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) 
    (Z_path E) z1 (Z_abs_aux_pos pa pb z1 E1)) =
inl (z2; Z_abs_aux_pos na nb z2 E3)
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: na + z2 = nb
E4: z2 = 0
inl
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) (Z_path E) z1
    (Z_abs_aux_pos pa pb z1 E1)) =
inl (0; Z_abs_aux_0 na nb z2 E3 E4) apply ap.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: na + z2 = nb
E4: z2 = 0
(transport (fun _ : Z => N) (Z_path E) z1;
transportD (fun _ : Z => N)
  (fun (x : Z) (y : N) =>
   naturals_to_semiring N Z y = x) (Z_path E) z1
  (Z_abs_aux_pos pa pb z1 E1)) =
(0; Z_abs_aux_0 na nb z2 E3 E4) apply Sigma.path_sigma_hprop.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: na + z2 = nb
E4: z2 = 0
(transport (fun _ : Z => N) (Z_path E) z1;
transportD (fun _ : Z => N)
  (fun (x : Z) (y : N) =>
   naturals_to_semiring N Z y = x) (Z_path E) z1
  (Z_abs_aux_pos pa pb z1 E1)).1 =
(0; Z_abs_aux_0 na nb z2 E3 E4).1 simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: na + z2 = nb
E4: z2 = 0
transport (fun _ : Z => N) (Z_path E) z1 = 0
    rewrite PathGroupoids.transport_const.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: na + z2 = nb
E4: z2 = 0
z1 = 0
    rewrite <-E1,<-E3,E4,plus_0_r in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pb + z1 + na = na + pb
E1: pb + z1 = pa
E3: na + z2 = nb
E4: z2 = 0
z1 = 0
    apply (left_cancellation plus (na+pb)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pb + z1 + na = na + pb
E1: pb + z1 = pa
E3: na + z2 = nb
E4: z2 = 0
na + pb + z1 = na + pb + 0
    rewrite plus_0_r.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pb + z1 + na = na + pb
E1: pb + z1 = pa
E3: na + z2 = nb
E4: z2 = 0
na + pb + z1 = na + pb
    path_via (pb + z1 + na).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pb + z1 + na = na + pb
E1: pb + z1 = pa
E3: na + z2 = nb
E4: z2 = 0
na + pb + z1 = pb + z1 + na ring_with_nat.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: na + z2 = nb
E4: z2 <> 0
inl
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) (Z_path E) z1
    (Z_abs_aux_pos pa pb z1 E1)) =
inr (z2; Z_abs_aux_neg na nb z2 E3) destruct E4.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: na + z2 = nb
z2 = 0
    rewrite <-E1,<-E3 in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pb + z1 + (na + z2) = na + pb
E1: pb + z1 = pa
E3: na + z2 = nb
z2 = 0
    assert (Hrw : pb + z1 + (na + z2) = (na + pb) + (z1 + z2))
    by ring_with_nat.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pb + z1 + (na + z2) = na + pb
E1: pb + z1 = pa
E3: na + z2 = nb
Hrw: pb + z1 + (na + z2) = na + pb + (z1 + z2)
z2 = 0
    rewrite <-(plus_0_r (na+pb)),Hrw in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: na + pb + (z1 + z2) = na + pb + 0
E1: pb + z1 = pa
E3: na + z2 = nb
Hrw: pb + z1 + (na + z2) = na + pb + (z1 + z2)
z2 = 0
    apply (left_cancellation _ _),naturals.zero_sum in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: ((z1 = 0) * (z2 = 0))%type
E1: pb + z1 = pa
E3: na + z2 = nb
Hrw: pb + z1 + (na + z2) = na + pb + (z1 + z2)
z2 = 0
    apply E.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: nb + z2 = na
inl
  (transport (fun _ : Z => N) (Z_path E) z1;
  transportD (fun _ : Z => N)
    (fun (x : Z) (y : N) =>
     naturals_to_semiring N Z y = x) (Z_path E) z1
    (Z_abs_aux_pos pa pb z1 E1)) =
inl (z2; Z_abs_aux_pos na nb z2 E3) apply ap,Sigma.path_sigma_hprop.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: nb + z2 = na
(transport (fun _ : Z => N) (Z_path E) z1;
transportD (fun _ : Z => N)
  (fun (x : Z) (y : N) =>
   naturals_to_semiring N Z y = x) (Z_path E) z1
  (Z_abs_aux_pos pa pb z1 E1)).1 =
(z2; Z_abs_aux_pos na nb z2 E3).1 simpl.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: nb + z2 = na
transport (fun _ : Z => N) (Z_path E) z1 = z2
    rewrite PathGroupoids.transport_const.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb: N
E: pa + nb = na + pb
z1: N
E1: pb + z1 = pa
z2: N
E3: nb + z2 = na
z1 = z2
    rewrite <-E1,<-E3 in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pb + z1 + nb = nb + z2 + pb
E1: pb + z1 = pa
E3: nb + z2 = na
z1 = z2
    apply (left_cancellation plus (pb+nb)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
pa, pb, na, nb, z1, z2: N
E: pb + z1 + nb = nb + z2 + pb
E1: pb + z1 = pa
E3: nb + z2 = na
pb + nb + z1 = pb + nb + z2
    path_via (pb + z1 + nb);[|path_via (nb + z2 + pb)];ring_with_nat.
Qed.

Lemma Z_abs' : IntAbs Z N.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
IntAbs Z N
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
IntAbs Z N
red.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall x : Z,
{n : N & naturals_to_semiring N Z n = x} +
{n : N & naturals_to_semiring N Z n = - x} apply (Z_rect _ Z_abs_def).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
forall (x y : T N) (E : equiv x y),
transport
  (fun q : Z =>
   ({n : N & naturals_to_semiring N Z n = q} +
    {n : N & naturals_to_semiring N Z n = - q})%type)
  (Z_path E) (Z_abs_def x) = Z_abs_def y
exact Z_abs_respects'.
Qed.

#[export] Instance Z_abs@{} : IntAbs@{UN UN UN UN UN
  UN UN UN UN UN
  UN UN UN UN UN
  UN UN} Z N
  := Z_abs'.

Notation n_to_z := (naturals_to_semiring N Z).

Definition zero_product_aux a b :
  n_to_z a * n_to_z b = 0 -> n_to_z a = 0 |_| n_to_z b = 0.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b: N
n_to_z a * n_to_z b = 0 ->
(n_to_z a = 0) + (n_to_z b = 0)
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b: N
n_to_z a * n_to_z b = 0 ->
(n_to_z a = 0) + (n_to_z b = 0)
rewrite <-rings.preserves_mult.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b: N
n_to_z (a * b) = 0 -> (n_to_z a = 0) + (n_to_z b = 0)
rewrite <-!(naturals.to_semiring_unique (cast N Z)).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b: N
' (a * b) = 0 -> (' a = 0) + (' b = 0)
intros E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b: N
E: ' (a * b) = 0
((' a = 0) + (' b = 0))%type
change 0 with (' 0) in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b: N
E: ' (a * b) = ' 0
((' a = 0) + (' b = 0))%type apply (injective _) in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b: N
E: a * b = 0
((' a = 0) + (' b = 0))%type
apply zero_product in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
a, b: N
E: ((a = 0) + (b = 0))%type
((' a = 0) + (' b = 0))%type
destruct E as [E|E];rewrite E;[left|right];apply preserves_0.
Qed.

Lemma Z_zero_product' : ZeroProduct Z.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
ZeroProduct Z
Proof.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
ZeroProduct Z
intros x y E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: x * y = 0
((x = 0) + (y = 0))%type
destruct (int_abs_sig Z N x) as [[a Ea]|[a Ea]],
  (int_abs_sig Z N y) as [[b Eb]|[b Eb]].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: x * y = 0
a: N
Ea: n_to_z a = x
b: N
Eb: n_to_z b = y
((x = 0) + (y = 0))%type
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: x * y = 0
a: N
Ea: n_to_z a = x
b: N
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: x * y = 0
a: N
Ea: n_to_z a = - x
b: N
Eb: n_to_z b = y
((x = 0) + (y = 0))%type
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: x * y = 0
a: N
Ea: n_to_z a = - x
b: N
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: x * y = 0
a: N
Ea: n_to_z a = x
b: N
Eb: n_to_z b = y
((x = 0) + (y = 0))%type rewrite <-Ea,<-Eb in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a * n_to_z b = 0
Ea: n_to_z a = x
Eb: n_to_z b = y
((x = 0) + (y = 0))%type
  apply zero_product_aux in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: ((n_to_z a = 0) + (n_to_z b = 0))%type
Ea: n_to_z a = x
Eb: n_to_z b = y
((x = 0) + (y = 0))%type
  rewrite <-Ea,<-Eb.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: ((n_to_z a = 0) + (n_to_z b = 0))%type
Ea: n_to_z a = x
Eb: n_to_z b = y
((n_to_z a = 0) + (n_to_z b = 0))%type
  trivial.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: x * y = 0
a: N
Ea: n_to_z a = x
b: N
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type apply (ap negate) in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: - (x * y) = - 0
a: N
Ea: n_to_z a = x
b: N
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type rewrite negate_mult_distr_r in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: x * - y = - 0
a: N
Ea: n_to_z a = x
b: N
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
  rewrite <-Ea,<-Eb in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a * n_to_z b = - 0
Ea: n_to_z a = x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
  rewrite negate_0 in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a * n_to_z b = 0
Ea: n_to_z a = x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
  apply zero_product_aux in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: ((n_to_z a = 0) + (n_to_z b = 0))%type
Ea: n_to_z a = x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
  destruct E as [E|E].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a = 0
Ea: n_to_z a = x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z b = 0
Ea: n_to_z a = x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a = 0
Ea: n_to_z a = x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type left;rewrite <-Ea;trivial.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z b = 0
Ea: n_to_z a = x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type right.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z b = 0
Ea: n_to_z a = x
Eb: n_to_z b = - y
y = 0
    apply (injective negate).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z b = 0
Ea: n_to_z a = x
Eb: n_to_z b = - y
- y = - 0
    rewrite negate_0,<-Eb;trivial.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: x * y = 0
a: N
Ea: n_to_z a = - x
b: N
Eb: n_to_z b = y
((x = 0) + (y = 0))%type apply (ap negate) in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: - (x * y) = - 0
a: N
Ea: n_to_z a = - x
b: N
Eb: n_to_z b = y
((x = 0) + (y = 0))%type rewrite negate_mult_distr_l in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: - x * y = - 0
a: N
Ea: n_to_z a = - x
b: N
Eb: n_to_z b = y
((x = 0) + (y = 0))%type
  rewrite <-Ea,<-Eb in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a * n_to_z b = - 0
Ea: n_to_z a = - x
Eb: n_to_z b = y
((x = 0) + (y = 0))%type
  rewrite negate_0 in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a * n_to_z b = 0
Ea: n_to_z a = - x
Eb: n_to_z b = y
((x = 0) + (y = 0))%type
  apply zero_product_aux in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: ((n_to_z a = 0) + (n_to_z b = 0))%type
Ea: n_to_z a = - x
Eb: n_to_z b = y
((x = 0) + (y = 0))%type
  destruct E as [E|E].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a = 0
Ea: n_to_z a = - x
Eb: n_to_z b = y
((x = 0) + (y = 0))%type
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z b = 0
Ea: n_to_z a = - x
Eb: n_to_z b = y
((x = 0) + (y = 0))%type
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a = 0
Ea: n_to_z a = - x
Eb: n_to_z b = y
((x = 0) + (y = 0))%type left.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a = 0
Ea: n_to_z a = - x
Eb: n_to_z b = y
x = 0
    apply (injective negate).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a = 0
Ea: n_to_z a = - x
Eb: n_to_z b = y
- x = - 0
    rewrite negate_0,<-Ea;trivial.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z b = 0
Ea: n_to_z a = - x
Eb: n_to_z b = y
((x = 0) + (y = 0))%type right;rewrite <-Eb;trivial.
-H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
E: x * y = 0
a: N
Ea: n_to_z a = - x
b: N
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type rewrite <-negate_mult_negate,<-Ea,<-Eb in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a * n_to_z b = 0
Ea: n_to_z a = - x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
  apply zero_product_aux in E.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: ((n_to_z a = 0) + (n_to_z b = 0))%type
Ea: n_to_z a = - x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
  destruct E as [E|E].H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a = 0
Ea: n_to_z a = - x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z b = 0
Ea: n_to_z a = - x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a = 0
Ea: n_to_z a = - x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type left.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a = 0
Ea: n_to_z a = - x
Eb: n_to_z b = - y
x = 0
    apply (injective negate).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z a = 0
Ea: n_to_z a = - x
Eb: n_to_z b = - y
- x = - 0
    rewrite negate_0,<-Ea;trivial.
  +H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z b = 0
Ea: n_to_z a = - x
Eb: n_to_z b = - y
((x = 0) + (y = 0))%type right.H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z b = 0
Ea: n_to_z a = - x
Eb: n_to_z b = - y
y = 0
    apply (injective negate).H: Funext
H0: Univalence
N: Type
Aap: Apart N
Aplus: Plus N
Amult: Mult N
Azero: Zero N
Aone: One N
Ale: Le N
Alt: Lt N
U: NaturalsToSemiRing N
H1: Naturals N
NatDistance0: NatDistance N
x, y: Z
a, b: N
E: n_to_z b = 0
Ea: n_to_z a = - x
Eb: n_to_z b = - y
- y = - 0
    rewrite negate_0,<-Eb;trivial.
Qed.

#[export] Instance Z_zero_product@{} : ZeroProduct Z
  := ltac:(first [exact Z_zero_product'@{Ularge Ularge}|
                  exact Z_zero_product'@{}]).

End contents.

Module Instances.
  Existing Instances
    T_set inject Tle_hprop Tlt_hprop Tapart_hprop Z_of_pair Z_of_N R_dec Z0 Z1 Z_plus Z_mult Z_negate Z_of_N_injective Zle ishprop_Zle Zle_cast_embedding Z_order Zle_dec Zlt ishprop_Zlt Z_strict_srorder Zlt_dec Zapart ishprop_Zapart Z_trivial_apart Z_to_ring Z_integers Z_abs Z_zero_product Z_of_N_morphism.
End Instances.
Export Instances.
End NatPair.