From ef7b77abf616ad159f6630eadb1a4f830e916563 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Fri, 28 Mar 2025 15:05:24 +0000 Subject: [PATCH 01/20] pull edits from `logic-compactness` --- .../representing-arrow-category.lagda.md | 54 +- .../decidable-types.lagda.md | 25 +- .../equality-natural-numbers.lagda.md | 11 +- ...st-common-divisor-natural-numbers.lagda.md | 5 +- .../inequality-natural-numbers.lagda.md | 19 +- .../kolakoski-sequence.lagda.md | 1 + .../negative-integers.lagda.md | 3 +- .../nonnegative-integers.lagda.md | 3 +- .../nonpositive-integers.lagda.md | 3 +- .../positive-integers.lagda.md | 3 +- ...rdering-principle-natural-numbers.lagda.md | 13 +- ...g-principle-standard-finite-types.lagda.md | 5 +- .../orbits-permutations.lagda.md | 3 +- src/foundation.lagda.md | 6 + src/foundation/booleans.lagda.md | 134 ++--- src/foundation/cantors-theorem.lagda.md | 106 ++-- ...ecidable-dependent-function-types.lagda.md | 121 +++- .../decidable-dependent-pair-types.lagda.md | 52 +- src/foundation/decidable-maps.lagda.md | 46 +- .../decidable-propositions.lagda.md | 24 +- src/foundation/decidable-subtypes.lagda.md | 8 +- .../decidable-type-families.lagda.md | 166 ++++++ src/foundation/decidable-types.lagda.md | 164 ++---- src/foundation/disjoint-subtypes.lagda.md | 4 + src/foundation/disjunction.lagda.md | 3 +- ...uble-negation-dense-equality-maps.lagda.md | 35 ++ .../double-negation-images.lagda.md | 299 ++++++++++ ...uble-negation-stable-propositions.lagda.md | 23 +- src/foundation/double-negation.lagda.md | 24 +- src/foundation/full-subtypes.lagda.md | 2 +- .../hilbert-epsilon-operators-maps.lagda.md | 93 ++++ .../hilberts-epsilon-operators.lagda.md | 5 +- src/foundation/images-subtypes.lagda.md | 2 +- src/foundation/images.lagda.md | 5 +- src/foundation/inequality-booleans.lagda.md | 226 ++++++++ src/foundation/injective-maps.lagda.md | 4 +- .../irrefutable-propositions.lagda.md | 92 +--- .../limited-principle-of-omniscience.lagda.md | 7 +- .../logical-operations-booleans.lagda.md | 297 ++++++++++ src/foundation/null-homotopic-maps.lagda.md | 6 - .../path-split-type-families.lagda.md | 2 +- src/foundation/projective-types.lagda.md | 5 +- .../propositional-truncations.lagda.md | 105 ++-- src/foundation/split-surjective-maps.lagda.md | 17 +- src/foundation/structure.lagda.md | 21 +- .../structured-type-duality.lagda.md | 2 +- src/foundation/surjective-maps.lagda.md | 11 + ...uniformly-decidable-type-families.lagda.md | 98 +++- ...universal-property-identity-types.lagda.md | 1 - src/logic.lagda.md | 8 + .../complements-decidable-subtypes.lagda.md | 55 +- src/logic/de-morgan-types.lagda.md | 11 +- src/logic/dirk-gentlys-principle.lagda.md | 68 +++ src/logic/double-negation-dense-maps.lagda.md | 516 ++++++++++++++++++ .../double-negation-dense-subtypes.lagda.md | 143 +++++ .../double-negation-eliminating-maps.lagda.md | 30 +- .../double-negation-elimination.lagda.md | 148 +++-- ...double-negation-stable-embeddings.lagda.md | 16 +- src/logic/irrefutable-types.lagda.md | 167 ++++++ src/logic/markovian-types.lagda.md | 13 +- ...ional-double-negation-elimination.lagda.md | 269 +++++++++ .../propositionally-decidable-maps.lagda.md | 187 +++++++ .../propositionally-decidable-types.lagda.md | 362 ++++++++++++ ...-double-negation-eliminating-maps.lagda.md | 124 +++++ .../homotopy-groups.lagda.md | 4 +- src/trees.lagda.md | 2 +- src/univalent-combinatorics/counting.lagda.md | 2 + ...ecidable-dependent-function-types.lagda.md | 4 +- .../dependent-pair-types.lagda.md | 2 + .../finite-types.lagda.md | 2 + 70 files changed, 3891 insertions(+), 606 deletions(-) create mode 100644 src/foundation/decidable-type-families.lagda.md create mode 100644 src/foundation/double-negation-dense-equality-maps.lagda.md create mode 100644 src/foundation/double-negation-images.lagda.md create mode 100644 src/foundation/hilbert-epsilon-operators-maps.lagda.md create mode 100644 src/foundation/inequality-booleans.lagda.md create mode 100644 src/foundation/logical-operations-booleans.lagda.md create mode 100644 src/logic/dirk-gentlys-principle.lagda.md create mode 100644 src/logic/double-negation-dense-maps.lagda.md create mode 100644 src/logic/double-negation-dense-subtypes.lagda.md create mode 100644 src/logic/irrefutable-types.lagda.md create mode 100644 src/logic/propositional-double-negation-elimination.lagda.md create mode 100644 src/logic/propositionally-decidable-maps.lagda.md create mode 100644 src/logic/propositionally-decidable-types.lagda.md create mode 100644 src/logic/propositionally-double-negation-eliminating-maps.lagda.md diff --git a/src/category-theory/representing-arrow-category.lagda.md b/src/category-theory/representing-arrow-category.lagda.md index dbdfec5962..b92c75bdbc 100644 --- a/src/category-theory/representing-arrow-category.lagda.md +++ b/src/category-theory/representing-arrow-category.lagda.md @@ -12,15 +12,20 @@ open import category-theory.isomorphisms-in-precategories open import category-theory.precategories open import foundation.booleans +open import foundation.decidable-propositions open import foundation.dependent-pair-types open import foundation.empty-types open import foundation.identity-types +open import foundation.inequality-booleans open import foundation.logical-equivalences +open import foundation.logical-operations-booleans open import foundation.propositions open import foundation.sets open import foundation.subtypes open import foundation.unit-type open import foundation.universe-levels + +open import order-theory.posets ``` @@ -42,9 +47,7 @@ obj-representing-arrow-Category = bool hom-set-representing-arrow-Category : obj-representing-arrow-Category → obj-representing-arrow-Category → Set lzero -hom-set-representing-arrow-Category true true = unit-Set -hom-set-representing-arrow-Category true false = empty-Set -hom-set-representing-arrow-Category false _ = unit-Set +hom-set-representing-arrow-Category x y = set-Prop (leq-bool-Prop x y) hom-representing-arrow-Category : obj-representing-arrow-Category → obj-representing-arrow-Category → UU lzero @@ -60,8 +63,8 @@ comp-hom-representing-arrow-Category : hom-representing-arrow-Category y z → hom-representing-arrow-Category x y → hom-representing-arrow-Category x z -comp-hom-representing-arrow-Category {true} {true} {true} _ _ = star -comp-hom-representing-arrow-Category {false} _ _ = star +comp-hom-representing-arrow-Category {x} {y} {z} = + transitive-leq-bool {x} {y} {z} associative-comp-hom-representing-arrow-Category : {x y z w : obj-representing-arrow-Category} → @@ -79,8 +82,7 @@ associative-comp-hom-representing-arrow-Category {false} h g f = refl id-hom-representing-arrow-Category : {x : obj-representing-arrow-Category} → hom-representing-arrow-Category x x -id-hom-representing-arrow-Category {true} = star -id-hom-representing-arrow-Category {false} = star +id-hom-representing-arrow-Category {x} = refl-leq-bool {x} left-unit-law-comp-hom-representing-arrow-Category : {x y : obj-representing-arrow-Category} → @@ -101,16 +103,7 @@ right-unit-law-comp-hom-representing-arrow-Category {true} {true} f = refl right-unit-law-comp-hom-representing-arrow-Category {false} f = refl representing-arrow-Precategory : Precategory lzero lzero -representing-arrow-Precategory = - make-Precategory - ( obj-representing-arrow-Category) - ( hom-set-representing-arrow-Category) - ( λ {x} {y} {z} → comp-hom-representing-arrow-Category {x} {y} {z}) - ( λ x → id-hom-representing-arrow-Category {x}) - ( λ {x} {y} {z} {w} → - associative-comp-hom-representing-arrow-Category {x} {y} {z} {w}) - ( λ {x} {y} → left-unit-law-comp-hom-representing-arrow-Category {x} {y}) - ( λ {x} {y} → right-unit-law-comp-hom-representing-arrow-Category {x} {y}) +representing-arrow-Precategory = precategory-Poset bool-Poset ``` ### The representing arrow category @@ -118,32 +111,11 @@ representing-arrow-Precategory = ```agda is-category-representing-arrow-Category : is-category-Precategory representing-arrow-Precategory -is-category-representing-arrow-Category true true = - is-equiv-has-converse-is-prop - ( is-set-bool true true) - ( is-prop-type-subtype - ( is-iso-prop-Precategory representing-arrow-Precategory {true} {true}) - ( is-prop-unit)) - ( λ _ → refl) -is-category-representing-arrow-Category true false = - is-equiv-is-empty - ( iso-eq-Precategory representing-arrow-Precategory true false) - ( hom-iso-Precategory representing-arrow-Precategory) -is-category-representing-arrow-Category false true = - is-equiv-is-empty - ( iso-eq-Precategory representing-arrow-Precategory false true) - ( hom-inv-iso-Precategory representing-arrow-Precategory) -is-category-representing-arrow-Category false false = - is-equiv-has-converse-is-prop - ( is-set-bool false false) - ( is-prop-type-subtype - ( is-iso-prop-Precategory representing-arrow-Precategory {false} {false}) - ( is-prop-unit)) - ( λ _ → refl) +is-category-representing-arrow-Category = + is-category-precategory-Poset bool-Poset representing-arrow-Category : Category lzero lzero -pr1 representing-arrow-Category = representing-arrow-Precategory -pr2 representing-arrow-Category = is-category-representing-arrow-Category +representing-arrow-Category = category-Poset bool-Poset ``` ## Properties diff --git a/src/elementary-number-theory/decidable-types.lagda.md b/src/elementary-number-theory/decidable-types.lagda.md index 047ada9a91..273fc1783c 100644 --- a/src/elementary-number-theory/decidable-types.lagda.md +++ b/src/elementary-number-theory/decidable-types.lagda.md @@ -14,6 +14,7 @@ open import elementary-number-theory.upper-bounds-natural-numbers open import foundation.cartesian-product-types open import foundation.coproduct-types +open import foundation.decidable-type-families open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.empty-types @@ -35,7 +36,7 @@ decidable. ```agda is-decidable-Σ-ℕ : - {l : Level} (m : ℕ) (P : ℕ → UU l) (d : is-decidable-fam P) → + {l : Level} (m : ℕ) (P : ℕ → UU l) (d : is-decidable-family P) → is-decidable (Σ ℕ (λ x → (leq-ℕ m x) × (P x))) → is-decidable (Σ ℕ P) is-decidable-Σ-ℕ m P d (inl (pair x (pair l p))) = inl (pair x p) is-decidable-Σ-ℕ zero-ℕ P d (inr f) = @@ -60,7 +61,7 @@ is-decidable-Σ-ℕ (succ-ℕ m) P d (inr f) with d zero-ℕ ```agda is-decidable-bounded-Σ-ℕ : {l1 l2 : Level} (m : ℕ) (P : ℕ → UU l1) (Q : ℕ → UU l2) - (dP : is-decidable-fam P) (dQ : is-decidable-fam Q) + (dP : is-decidable-family P) (dQ : is-decidable-family Q) (H : is-upper-bound-ℕ P m) → is-decidable (Σ ℕ (λ x → (P x) × (Q x))) is-decidable-bounded-Σ-ℕ m P Q dP dQ H = is-decidable-Σ-ℕ @@ -76,7 +77,7 @@ is-decidable-bounded-Σ-ℕ m P Q dP dQ H = ( pr1 (pr2 p)))) is-decidable-bounded-Σ-ℕ' : - {l : Level} (m : ℕ) (P : ℕ → UU l) (d : is-decidable-fam P) → + {l : Level} (m : ℕ) (P : ℕ → UU l) (d : is-decidable-family P) → is-decidable (Σ ℕ (λ x → (leq-ℕ x m) × (P x))) is-decidable-bounded-Σ-ℕ' m P d = is-decidable-bounded-Σ-ℕ m @@ -92,7 +93,7 @@ is-decidable-bounded-Σ-ℕ' m P d = ```agda is-decidable-strictly-bounded-Σ-ℕ : {l1 l2 : Level} (m : ℕ) (P : ℕ → UU l1) (Q : ℕ → UU l2) - (dP : is-decidable-fam P) (dQ : is-decidable-fam Q) + (dP : is-decidable-family P) (dQ : is-decidable-family Q) (H : is-strict-upper-bound-ℕ P m) → is-decidable (Σ ℕ (λ x → (P x) × (Q x))) is-decidable-strictly-bounded-Σ-ℕ m P Q dP dQ H = @@ -100,7 +101,7 @@ is-decidable-strictly-bounded-Σ-ℕ m P Q dP dQ H = ( is-upper-bound-is-strict-upper-bound-ℕ P m H) is-decidable-strictly-bounded-Σ-ℕ' : - {l : Level} (m : ℕ) (P : ℕ → UU l) (d : is-decidable-fam P) → + {l : Level} (m : ℕ) (P : ℕ → UU l) (d : is-decidable-family P) → is-decidable (Σ ℕ (λ x → (le-ℕ x m) × (P x))) is-decidable-strictly-bounded-Σ-ℕ' m P d = is-decidable-strictly-bounded-Σ-ℕ m @@ -115,7 +116,7 @@ is-decidable-strictly-bounded-Σ-ℕ' m P d = ```agda is-decidable-Π-ℕ : - {l : Level} (P : ℕ → UU l) (d : is-decidable-fam P) (m : ℕ) → + {l : Level} (P : ℕ → UU l) (d : is-decidable-family P) (m : ℕ) → is-decidable ((x : ℕ) → (leq-ℕ m x) → P x) → is-decidable ((x : ℕ) → P x) is-decidable-Π-ℕ P d zero-ℕ (inr nH) = inr (λ f → nH (λ x y → f x)) is-decidable-Π-ℕ P d zero-ℕ (inl H) = inl (λ x → H x (leq-zero-ℕ x)) @@ -136,8 +137,8 @@ is-decidable-Π-ℕ P d (succ-ℕ m) (inl H) with d zero-ℕ ```agda is-decidable-bounded-Π-ℕ : - {l1 l2 : Level} (P : ℕ → UU l1) (Q : ℕ → UU l2) (dP : is-decidable-fam P) → - (dQ : is-decidable-fam Q) (m : ℕ) (H : is-upper-bound-ℕ P m) → + {l1 l2 : Level} (P : ℕ → UU l1) (Q : ℕ → UU l2) (dP : is-decidable-family P) → + (dQ : is-decidable-family Q) (m : ℕ) (H : is-upper-bound-ℕ P m) → is-decidable ((x : ℕ) → P x → Q x) is-decidable-bounded-Π-ℕ P Q dP dQ m H = is-decidable-Π-ℕ @@ -147,7 +148,7 @@ is-decidable-bounded-Π-ℕ P Q dP dQ m H = ( inl (λ x l p → ex-falso (contradiction-leq-ℕ x m (H x p) l))) is-decidable-bounded-Π-ℕ' : - {l : Level} (P : ℕ → UU l) (d : is-decidable-fam P) (m : ℕ) → + {l : Level} (P : ℕ → UU l) (d : is-decidable-family P) (m : ℕ) → is-decidable ((x : ℕ) → (leq-ℕ x m) → P x) is-decidable-bounded-Π-ℕ' P d m = is-decidable-bounded-Π-ℕ @@ -163,14 +164,14 @@ is-decidable-bounded-Π-ℕ' P d m = ```agda is-decidable-strictly-bounded-Π-ℕ : - {l1 l2 : Level} (P : ℕ → UU l1) (Q : ℕ → UU l2) (dP : is-decidable-fam P) → - (dQ : is-decidable-fam Q) (m : ℕ) (H : is-strict-upper-bound-ℕ P m) → + {l1 l2 : Level} (P : ℕ → UU l1) (Q : ℕ → UU l2) (dP : is-decidable-family P) → + (dQ : is-decidable-family Q) (m : ℕ) (H : is-strict-upper-bound-ℕ P m) → is-decidable ((x : ℕ) → P x → Q x) is-decidable-strictly-bounded-Π-ℕ P Q dP dQ m H = is-decidable-bounded-Π-ℕ P Q dP dQ m (λ x p → leq-le-ℕ x m (H x p)) is-decidable-strictly-bounded-Π-ℕ' : - {l : Level} (P : ℕ → UU l) (d : is-decidable-fam P) (m : ℕ) → + {l : Level} (P : ℕ → UU l) (d : is-decidable-family P) (m : ℕ) → is-decidable ((x : ℕ) → le-ℕ x m → P x) is-decidable-strictly-bounded-Π-ℕ' P d m = is-decidable-strictly-bounded-Π-ℕ diff --git a/src/elementary-number-theory/equality-natural-numbers.lagda.md b/src/elementary-number-theory/equality-natural-numbers.lagda.md index bb335e5e58..1c5fb74ff5 100644 --- a/src/elementary-number-theory/equality-natural-numbers.lagda.md +++ b/src/elementary-number-theory/equality-natural-numbers.lagda.md @@ -14,6 +14,7 @@ open import foundation.coproduct-types open import foundation.decidable-equality open import foundation.decidable-types open import foundation.dependent-pair-types +open import foundation.discrete-types open import foundation.empty-types open import foundation.equivalences open import foundation.function-types @@ -22,11 +23,11 @@ open import foundation.identity-types open import foundation.propositions open import foundation.set-truncations open import foundation.sets +open import foundation.tight-apartness-relations open import foundation.unit-type open import foundation.universe-levels open import foundation-core.decidable-propositions -open import foundation-core.discrete-types open import foundation-core.torsorial-type-families ``` @@ -179,3 +180,11 @@ is-equiv-Eq-eq-ℕ {m} {n} = equiv-unit-trunc-ℕ-Set : ℕ ≃ type-trunc-Set ℕ equiv-unit-trunc-ℕ-Set = equiv-unit-trunc-Set ℕ-Set ``` + +### The natural numbers have a tight apartness relation + +```agda +ℕ-Type-With-Tight-Apartness : Type-With-Tight-Apartness lzero lzero +ℕ-Type-With-Tight-Apartness = + type-with-tight-apartness-Discrete-Type ℕ-Discrete-Type +``` diff --git a/src/elementary-number-theory/greatest-common-divisor-natural-numbers.lagda.md b/src/elementary-number-theory/greatest-common-divisor-natural-numbers.lagda.md index 13347d69ac..bc14f911c8 100644 --- a/src/elementary-number-theory/greatest-common-divisor-natural-numbers.lagda.md +++ b/src/elementary-number-theory/greatest-common-divisor-natural-numbers.lagda.md @@ -24,6 +24,7 @@ open import elementary-number-theory.well-ordering-principle-natural-numbers open import foundation.action-on-identifications-functions open import foundation.cartesian-product-types open import foundation.coproduct-types +open import foundation.decidable-type-families open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.empty-types @@ -87,7 +88,7 @@ pr2 (refl-is-common-divisor-ℕ x) = refl-div-ℕ x ```agda is-decidable-is-common-divisor-ℕ : - (a b : ℕ) → is-decidable-fam (is-common-divisor-ℕ a b) + (a b : ℕ) → is-decidable-family (is-common-divisor-ℕ a b) is-decidable-is-common-divisor-ℕ a b x = is-decidable-product ( is-decidable-div-ℕ x a) @@ -137,7 +138,7 @@ leq-sum-is-common-divisor-ℕ a b d H = ```agda is-decidable-is-multiple-of-gcd-ℕ : - (a b : ℕ) → is-decidable-fam (is-multiple-of-gcd-ℕ a b) + (a b : ℕ) → is-decidable-family (is-multiple-of-gcd-ℕ a b) is-decidable-is-multiple-of-gcd-ℕ a b n = is-decidable-function-type' ( is-decidable-neg (is-decidable-is-zero-ℕ (a +ℕ b))) diff --git a/src/elementary-number-theory/inequality-natural-numbers.lagda.md b/src/elementary-number-theory/inequality-natural-numbers.lagda.md index a31c50691d..f536153a61 100644 --- a/src/elementary-number-theory/inequality-natural-numbers.lagda.md +++ b/src/elementary-number-theory/inequality-natural-numbers.lagda.md @@ -182,13 +182,16 @@ cases-order-three-elements-ℕ x y z = order-three-elements-ℕ : (x y z : ℕ) → cases-order-three-elements-ℕ x y z -order-three-elements-ℕ zero-ℕ zero-ℕ zero-ℕ = inl (inl (pair star star)) -order-three-elements-ℕ zero-ℕ zero-ℕ (succ-ℕ z) = inl (inl (pair star star)) -order-three-elements-ℕ zero-ℕ (succ-ℕ y) zero-ℕ = inl (inr (pair star star)) +order-three-elements-ℕ zero-ℕ zero-ℕ zero-ℕ = + inl (inl (star , star)) +order-three-elements-ℕ zero-ℕ zero-ℕ (succ-ℕ z) = + inl (inl (star , star)) +order-three-elements-ℕ zero-ℕ (succ-ℕ y) zero-ℕ = + inl (inr (star , star)) order-three-elements-ℕ zero-ℕ (succ-ℕ y) (succ-ℕ z) = inl (map-coproduct (pair star) (pair star) (linear-leq-ℕ y z)) order-three-elements-ℕ (succ-ℕ x) zero-ℕ zero-ℕ = - inr (inl (inl (pair star star))) + inr (inl (inl (star , star))) order-three-elements-ℕ (succ-ℕ x) zero-ℕ (succ-ℕ z) = inr (inl (map-coproduct (pair star) (pair star) (linear-leq-ℕ z x))) order-three-elements-ℕ (succ-ℕ x) (succ-ℕ y) zero-ℕ = @@ -362,8 +365,8 @@ leq-add-ℕ' m n = ```agda subtraction-leq-ℕ : (n m : ℕ) → n ≤-ℕ m → Σ ℕ (λ l → l +ℕ n ＝ m) -subtraction-leq-ℕ zero-ℕ m p = pair m refl -subtraction-leq-ℕ (succ-ℕ n) (succ-ℕ m) p = pair (pr1 P) (ap succ-ℕ (pr2 P)) +subtraction-leq-ℕ zero-ℕ m p = (m , refl) +subtraction-leq-ℕ (succ-ℕ n) (succ-ℕ m) p = (pr1 P , ap succ-ℕ (pr2 P)) where P : Σ ℕ (λ l' → l' +ℕ n ＝ m) P = subtraction-leq-ℕ n m p @@ -450,12 +453,12 @@ leq-mul-ℕ' k x = leq-mul-is-nonzero-ℕ : (k x : ℕ) → is-nonzero-ℕ k → x ≤-ℕ (x *ℕ k) leq-mul-is-nonzero-ℕ k x H with is-successor-is-nonzero-ℕ H -... | pair l refl = leq-mul-ℕ l x +... | (l , refl) = leq-mul-ℕ l x leq-mul-is-nonzero-ℕ' : (k x : ℕ) → is-nonzero-ℕ k → x ≤-ℕ (k *ℕ x) leq-mul-is-nonzero-ℕ' k x H with is-successor-is-nonzero-ℕ H -... | pair l refl = leq-mul-ℕ' l x +... | (l , refl) = leq-mul-ℕ' l x ``` ## See also diff --git a/src/elementary-number-theory/kolakoski-sequence.lagda.md b/src/elementary-number-theory/kolakoski-sequence.lagda.md index 602bc2597a..cdc0b8b321 100644 --- a/src/elementary-number-theory/kolakoski-sequence.lagda.md +++ b/src/elementary-number-theory/kolakoski-sequence.lagda.md @@ -14,6 +14,7 @@ open import elementary-number-theory.strong-induction-natural-numbers open import foundation.booleans open import foundation.cartesian-product-types open import foundation.dependent-pair-types +open import foundation.logical-operations-booleans ``` diff --git a/src/elementary-number-theory/negative-integers.lagda.md b/src/elementary-number-theory/negative-integers.lagda.md index a549a3ae37..7bc2494ac5 100644 --- a/src/elementary-number-theory/negative-integers.lagda.md +++ b/src/elementary-number-theory/negative-integers.lagda.md @@ -14,6 +14,7 @@ open import elementary-number-theory.nonzero-integers open import foundation.action-on-identifications-functions open import foundation.coproduct-types open import foundation.decidable-subtypes +open import foundation.decidable-type-families open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.empty-types @@ -96,7 +97,7 @@ neg-one-negative-ℤ = (neg-one-ℤ , star) ### Negativity is decidable ```agda -is-decidable-is-negative-ℤ : is-decidable-fam is-negative-ℤ +is-decidable-is-negative-ℤ : is-decidable-family is-negative-ℤ is-decidable-is-negative-ℤ (inl x) = inl star is-decidable-is-negative-ℤ (inr x) = inr id diff --git a/src/elementary-number-theory/nonnegative-integers.lagda.md b/src/elementary-number-theory/nonnegative-integers.lagda.md index 6f9d446eca..9c06ff7fb4 100644 --- a/src/elementary-number-theory/nonnegative-integers.lagda.md +++ b/src/elementary-number-theory/nonnegative-integers.lagda.md @@ -13,6 +13,7 @@ open import elementary-number-theory.natural-numbers open import foundation.action-on-identifications-functions open import foundation.coproduct-types open import foundation.decidable-subtypes +open import foundation.decidable-type-families open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.empty-types @@ -98,7 +99,7 @@ one-nonnegative-ℤ = (one-ℤ , star) ### Nonnegativity is decidable ```agda -is-decidable-is-nonnegative-ℤ : is-decidable-fam is-nonnegative-ℤ +is-decidable-is-nonnegative-ℤ : is-decidable-family is-nonnegative-ℤ is-decidable-is-nonnegative-ℤ (inl x) = inr id is-decidable-is-nonnegative-ℤ (inr x) = inl star diff --git a/src/elementary-number-theory/nonpositive-integers.lagda.md b/src/elementary-number-theory/nonpositive-integers.lagda.md index 423216dbe2..2fb4ab4cb4 100644 --- a/src/elementary-number-theory/nonpositive-integers.lagda.md +++ b/src/elementary-number-theory/nonpositive-integers.lagda.md @@ -13,6 +13,7 @@ open import elementary-number-theory.natural-numbers open import foundation.action-on-identifications-functions open import foundation.coproduct-types open import foundation.decidable-subtypes +open import foundation.decidable-type-families open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.empty-types @@ -100,7 +101,7 @@ neg-one-nonpositive-ℤ = (neg-one-ℤ , star) ### Nonpositivity is decidable ```agda -is-decidable-is-nonpositive-ℤ : is-decidable-fam is-nonpositive-ℤ +is-decidable-is-nonpositive-ℤ : is-decidable-family is-nonpositive-ℤ is-decidable-is-nonpositive-ℤ (inl x) = inl star is-decidable-is-nonpositive-ℤ (inr (inl x)) = inl star is-decidable-is-nonpositive-ℤ (inr (inr x)) = inr id diff --git a/src/elementary-number-theory/positive-integers.lagda.md b/src/elementary-number-theory/positive-integers.lagda.md index bc942b406f..c5cae426ab 100644 --- a/src/elementary-number-theory/positive-integers.lagda.md +++ b/src/elementary-number-theory/positive-integers.lagda.md @@ -15,6 +15,7 @@ open import elementary-number-theory.nonzero-natural-numbers open import foundation.action-on-identifications-functions open import foundation.coproduct-types open import foundation.decidable-subtypes +open import foundation.decidable-type-families open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.empty-types @@ -105,7 +106,7 @@ one-positive-ℤ = (one-ℤ , star) ### Positivity is decidable ```agda -is-decidable-is-positive-ℤ : is-decidable-fam is-positive-ℤ +is-decidable-is-positive-ℤ : is-decidable-family is-positive-ℤ is-decidable-is-positive-ℤ (inl x) = inr id is-decidable-is-positive-ℤ (inr (inl x)) = inr id is-decidable-is-positive-ℤ (inr (inr x)) = inl star diff --git a/src/elementary-number-theory/well-ordering-principle-natural-numbers.lagda.md b/src/elementary-number-theory/well-ordering-principle-natural-numbers.lagda.md index a72905645f..c17dbcafba 100644 --- a/src/elementary-number-theory/well-ordering-principle-natural-numbers.lagda.md +++ b/src/elementary-number-theory/well-ordering-principle-natural-numbers.lagda.md @@ -13,6 +13,7 @@ open import elementary-number-theory.natural-numbers open import foundation.cartesian-product-types open import foundation.coproduct-types +open import foundation.decidable-type-families open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.empty-types @@ -66,7 +67,7 @@ module _ pr2 minimal-element-ℕ-Prop = is-prop-minimal-element-ℕ is-minimal-element-succ-ℕ : - {l : Level} (P : ℕ → UU l) (d : is-decidable-fam P) + {l : Level} (P : ℕ → UU l) (d : is-decidable-family P) (m : ℕ) (pm : P (succ-ℕ m)) (is-lower-bound-m : is-lower-bound-ℕ (λ x → P (succ-ℕ x)) m) → ¬ (P zero-ℕ) → is-lower-bound-ℕ P (succ-ℕ m) @@ -80,7 +81,7 @@ is-minimal-element-succ-ℕ is-lower-bound-m n psuccn well-ordering-principle-succ-ℕ : - {l : Level} (P : ℕ → UU l) (d : is-decidable-fam P) + {l : Level} (P : ℕ → UU l) (d : is-decidable-family P) (n : ℕ) (p : P (succ-ℕ n)) → is-decidable (P zero-ℕ) → minimal-element-ℕ (λ m → P (succ-ℕ m)) → minimal-element-ℕ P @@ -90,7 +91,7 @@ well-ordering-principle-succ-ℕ P d n p (inr neg-p0) (m , pm , is-min-m) = ( succ-ℕ m , pm , is-minimal-element-succ-ℕ P d m pm is-min-m neg-p0) well-ordering-principle-ℕ : - {l : Level} (P : ℕ → UU l) (d : is-decidable-fam P) → + {l : Level} (P : ℕ → UU l) (d : is-decidable-family P) → Σ ℕ P → minimal-element-ℕ P pr1 (well-ordering-principle-ℕ P d (pair zero-ℕ p)) = zero-ℕ pr1 (pr2 (well-ordering-principle-ℕ P d (pair zero-ℕ p))) = p @@ -103,7 +104,7 @@ well-ordering-principle-ℕ P d (pair (succ-ℕ n) p) = ( pair n p)) number-well-ordering-principle-ℕ : - {l : Level} (P : ℕ → UU l) (d : is-decidable-fam P) (nP : Σ ℕ P) → ℕ + {l : Level} (P : ℕ → UU l) (d : is-decidable-family P) (nP : Σ ℕ P) → ℕ number-well-ordering-principle-ℕ P d nP = pr1 (well-ordering-principle-ℕ P d nP) ``` @@ -114,7 +115,7 @@ This is independently of the input `(pair n p) : Σ ℕ P`. ```agda is-zero-well-ordering-principle-succ-ℕ : - {l : Level} (P : ℕ → UU l) (d : is-decidable-fam P) + {l : Level} (P : ℕ → UU l) (d : is-decidable-family P) (n : ℕ) (p : P (succ-ℕ n)) (d0 : is-decidable (P zero-ℕ)) → (x : minimal-element-ℕ (λ m → P (succ-ℕ m))) (p0 : P zero-ℕ) → pr1 (well-ordering-principle-succ-ℕ P d n p d0 x) ＝ zero-ℕ @@ -124,7 +125,7 @@ is-zero-well-ordering-principle-succ-ℕ P d n p (inr np0) x q0 = ex-falso (np0 q0) is-zero-well-ordering-principle-ℕ : - {l : Level} (P : ℕ → UU l) (d : is-decidable-fam P) → + {l : Level} (P : ℕ → UU l) (d : is-decidable-family P) → (x : Σ ℕ P) → P zero-ℕ → is-zero-ℕ (number-well-ordering-principle-ℕ P d x) is-zero-well-ordering-principle-ℕ P d (pair zero-ℕ p) p0 = refl is-zero-well-ordering-principle-ℕ P d (pair (succ-ℕ m) p) = diff --git a/src/elementary-number-theory/well-ordering-principle-standard-finite-types.lagda.md b/src/elementary-number-theory/well-ordering-principle-standard-finite-types.lagda.md index a422c722f0..c8d6c7ef26 100644 --- a/src/elementary-number-theory/well-ordering-principle-standard-finite-types.lagda.md +++ b/src/elementary-number-theory/well-ordering-principle-standard-finite-types.lagda.md @@ -15,6 +15,7 @@ open import elementary-number-theory.well-ordering-principle-natural-numbers open import foundation.cartesian-product-types open import foundation.coproduct-types open import foundation.decidable-subtypes +open import foundation.decidable-type-families open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.empty-types @@ -56,7 +57,7 @@ numbers. ```agda exists-not-not-for-all-Fin : - {l : Level} (k : ℕ) {P : Fin k → UU l} → (is-decidable-fam P) → + {l : Level} (k : ℕ) {P : Fin k → UU l} → (is-decidable-family P) → ¬ ((x : Fin k) → P x) → Σ (Fin k) (λ x → ¬ (P x)) exists-not-not-for-all-Fin {l} zero-ℕ d H = ex-falso (H ind-empty) exists-not-not-for-all-Fin {l} (succ-ℕ k) {P} d H with d (inr star) @@ -71,7 +72,7 @@ exists-not-not-for-all-Fin {l} (succ-ℕ k) {P} d H with d (inr star) exists-not-not-for-all-count : {l1 l2 : Level} {X : UU l1} (P : X → UU l2) → - (is-decidable-fam P) → count X → + (is-decidable-family P) → count X → ¬ ((x : X) → P x) → Σ X (λ x → ¬ (P x)) exists-not-not-for-all-count {l1} {l2} {X} P p e = ( g) ∘ diff --git a/src/finite-group-theory/orbits-permutations.lagda.md b/src/finite-group-theory/orbits-permutations.lagda.md index 06919a3b39..835bcc5323 100644 --- a/src/finite-group-theory/orbits-permutations.lagda.md +++ b/src/finite-group-theory/orbits-permutations.lagda.md @@ -55,6 +55,8 @@ open import foundation.universe-levels open import lists.lists +open import logic.propositionally-decidable-types + open import univalent-combinatorics.2-element-decidable-subtypes open import univalent-combinatorics.2-element-types open import univalent-combinatorics.counting @@ -491,7 +493,6 @@ module _ ( prop-equivalence-relation same-orbits-permutation a b)) ( λ h → is-decidable-trunc-Prop-is-merely-decidable - ( Σ ℕ (λ k → Id (iterate k (map-equiv f) a) b)) ( unit-trunc-Prop ( is-decidable-iterate-is-decidable-bounded h a b ( is-decidable-bounded-Σ-ℕ n diff --git a/src/foundation.lagda.md b/src/foundation.lagda.md index 429dd75e39..abfcf94775 100644 --- a/src/foundation.lagda.md +++ b/src/foundation.lagda.md @@ -110,6 +110,7 @@ open import foundation.decidable-maps public open import foundation.decidable-propositions public open import foundation.decidable-relations public open import foundation.decidable-subtypes public +open import foundation.decidable-type-families public open import foundation.decidable-types public open import foundation.dependent-binary-homotopies public open import foundation.dependent-binomial-theorem public @@ -144,6 +145,8 @@ open import foundation.disjoint-subtypes public open import foundation.disjunction public open import foundation.double-arrows public open import foundation.double-negation public +open import foundation.double-negation-dense-equality-maps public +open import foundation.double-negation-images public open import foundation.double-negation-modality public open import foundation.double-negation-stable-equality public open import foundation.double-negation-stable-propositions public @@ -222,6 +225,7 @@ open import foundation.global-subuniverses public open import foundation.globular-type-of-dependent-functions public open import foundation.globular-type-of-functions public open import foundation.higher-homotopies-morphisms-arrows public +open import foundation.hilbert-epsilon-operators-maps public open import foundation.hilberts-epsilon-operators public open import foundation.homotopies public open import foundation.homotopies-morphisms-arrows public @@ -240,6 +244,7 @@ open import foundation.implicit-function-types public open import foundation.impredicative-encodings public open import foundation.impredicative-universes public open import foundation.induction-principle-propositional-truncation public +open import foundation.inequality-booleans public open import foundation.infinitely-coherent-equivalences public open import foundation.inhabited-subtypes public open import foundation.inhabited-types public @@ -275,6 +280,7 @@ open import foundation.limited-principle-of-omniscience public open import foundation.locale-of-propositions public open import foundation.locally-small-types public open import foundation.logical-equivalences public +open import foundation.logical-operations-booleans public open import foundation.maps-in-global-subuniverses public open import foundation.maps-in-subuniverses public open import foundation.maybe public diff --git a/src/foundation/booleans.lagda.md b/src/foundation/booleans.lagda.md index 712d69cc6b..efa937da3b 100644 --- a/src/foundation/booleans.lagda.md +++ b/src/foundation/booleans.lagda.md @@ -7,6 +7,7 @@ module foundation.booleans where
Imports ```agda +open import foundation.apartness-relations open import foundation.decidable-equality open import foundation.decidable-types open import foundation.dependent-pair-types @@ -14,11 +15,14 @@ open import foundation.discrete-types open import foundation.involutions open import foundation.negated-equality open import foundation.raising-universe-levels +open import foundation.tight-apartness-relations open import foundation.unit-type open import foundation.universe-levels open import foundation-core.constant-maps open import foundation-core.coproduct-types +open import foundation-core.decidable-propositions +open import foundation-core.double-negation-stable-equality open import foundation-core.empty-types open import foundation-core.equivalences open import foundation-core.function-types @@ -38,8 +42,8 @@ open import univalent-combinatorics.standard-finite-types ## Idea -The type of **booleans** is a -[2-element type](univalent-combinatorics.2-element-types.md) with elements +The type of {{#concept "booleans" WD="Boolean domain" WDID=Q3269980 Agda=bool}} +is a [2-element type](univalent-combinatorics.2-element-types.md) with elements `true false : bool`, which is used for reasoning with [decidable propositions](foundation-core.decidable-propositions.md). @@ -144,34 +148,20 @@ neq-false-true-bool () neq-true-false-bool : true ≠ false neq-true-false-bool () -``` -## Structure +is-decidable-Eq-bool : {x y : bool} → is-decidable (Eq-bool x y) +is-decidable-Eq-bool {true} {true} = inl star +is-decidable-Eq-bool {true} {false} = inr id +is-decidable-Eq-bool {false} {true} = inr id +is-decidable-Eq-bool {false} {false} = inl star +``` -### The boolean operators +### The standard interpretation of booleans as decidable propositions ```agda -neg-bool : bool → bool -neg-bool true = false -neg-bool false = true - -conjunction-bool : bool → bool → bool -conjunction-bool true true = true -conjunction-bool true false = false -conjunction-bool false true = false -conjunction-bool false false = false - -disjunction-bool : bool → bool → bool -disjunction-bool true true = true -disjunction-bool true false = true -disjunction-bool false true = true -disjunction-bool false false = false - -implication-bool : bool → bool → bool -implication-bool true true = true -implication-bool true false = false -implication-bool false true = true -implication-bool false false = true +decidable-prop-bool : bool → Decidable-Prop lzero +decidable-prop-bool true = unit-Decidable-Prop +decidable-prop-bool false = empty-Decidable-Prop ``` ## Properties @@ -210,6 +200,19 @@ has-decidable-equality-bool false false = inl refl bool-Discrete-Type : Discrete-Type lzero bool-Discrete-Type = bool , has-decidable-equality-bool + +has-double-negation-stable-equality-bool : + has-double-negation-stable-equality bool +has-double-negation-stable-equality-bool x y = + double-negation-elim-is-decidable (has-decidable-equality-bool x y) +``` + +### The booleans have a tight apartness relation + +```agda +bool-Type-With-Tight-Apartness : Type-With-Tight-Apartness lzero lzero +bool-Type-With-Tight-Apartness = + type-with-tight-apartness-Discrete-Type bool-Discrete-Type ``` ### The "is true" predicate on booleans @@ -222,7 +225,14 @@ is-prop-is-true : (b : bool) → is-prop (is-true b) is-prop-is-true b = is-set-bool b true is-true-Prop : bool → Prop lzero -is-true-Prop b = is-true b , is-prop-is-true b +is-true-Prop b = (is-true b , is-prop-is-true b) + +is-decidable-prop-is-true : (b : bool) → is-decidable-prop (is-true b) +is-decidable-prop-is-true b = + ( is-prop-is-true b , has-decidable-equality-bool b true) + +is-true-Decidable-Prop : bool → Decidable-Prop lzero +is-true-Decidable-Prop b = (is-true b , is-decidable-prop-is-true b) ``` ### The "is false" predicate on booleans @@ -236,18 +246,43 @@ is-prop-is-false b = is-set-bool b false is-false-Prop : bool → Prop lzero is-false-Prop b = is-false b , is-prop-is-false b + +is-decidable-prop-is-false : (b : bool) → is-decidable-prop (is-false b) +is-decidable-prop-is-false b = + ( is-prop-is-false b , has-decidable-equality-bool b false) + +is-false-Decidable-Prop : bool → Decidable-Prop lzero +is-false-Decidable-Prop b = (is-false b , is-decidable-prop-is-false b) ``` ### A boolean cannot be both true and false ```agda -not-is-false-is-true : (x : bool) → is-true x → ¬ (is-false x) -not-is-false-is-true true t () -not-is-false-is-true false () f - -not-is-true-is-false : (x : bool) → is-false x → ¬ (is-true x) -not-is-true-is-false true () f -not-is-true-is-false false t () +is-not-false-is-true : (x : bool) → is-true x → ¬ (is-false x) +is-not-false-is-true true t () +is-not-false-is-true false () f + +is-not-true-is-false : (x : bool) → is-false x → ¬ (is-true x) +is-not-true-is-false true () f +is-not-true-is-false false t () + +is-false-is-not-true : (x : bool) → ¬ (is-true x) → is-false x +is-false-is-not-true true np = ex-falso (np refl) +is-false-is-not-true false np = refl + +is-true-is-not-false : (x : bool) → ¬ (is-false x) → is-true x +is-true-is-not-false true np = refl +is-true-is-not-false false np = ex-falso (np refl) + +contrapositive-is-true-bool : + {x y : bool} → (is-true x → is-true y) → is-false y → is-false x +contrapositive-is-true-bool {x} f refl = + is-false-is-not-true x (neq-false-true-bool ∘ f) + +contrapositive-is-false-bool : + {x y : bool} → (is-false x → is-false y) → is-true y → is-true x +contrapositive-is-false-bool {x} f refl = + is-true-is-not-false x (neq-true-false-bool ∘ f) ``` ### The type of booleans is equivalent to `Fin 2` @@ -298,37 +333,6 @@ pr1 bool-Finite-Type = bool pr2 bool-Finite-Type = is-finite-bool ``` -### Boolean negation has no fixed points - -```agda -neq-neg-bool : (b : bool) → b ≠ neg-bool b -neq-neg-bool true () -neq-neg-bool false () - -neq-neg-bool' : (b : bool) → neg-bool b ≠ b -neq-neg-bool' b = neq-neg-bool b ∘ inv -``` - -### Boolean negation is an involution - -```agda -is-involution-neg-bool : is-involution neg-bool -is-involution-neg-bool true = refl -is-involution-neg-bool false = refl -``` - -### Boolean negation is an equivalence - -```agda -abstract - is-equiv-neg-bool : is-equiv neg-bool - is-equiv-neg-bool = is-equiv-is-involution is-involution-neg-bool - -equiv-neg-bool : bool ≃ bool -pr1 equiv-neg-bool = neg-bool -pr2 equiv-neg-bool = is-equiv-neg-bool -``` - ### The constant function `const bool b` is not an equivalence ```agda diff --git a/src/foundation/cantors-theorem.lagda.md b/src/foundation/cantors-theorem.lagda.md index 499ebf65d6..2abcbd3a35 100644 --- a/src/foundation/cantors-theorem.lagda.md +++ b/src/foundation/cantors-theorem.lagda.md @@ -16,16 +16,14 @@ open import foundation.function-extensionality open import foundation.logical-equivalences open import foundation.negation open import foundation.powersets -open import foundation.propositional-truncations open import foundation.surjective-maps open import foundation.universe-levels -open import foundation-core.empty-types open import foundation-core.fibers-of-maps -open import foundation-core.propositions open import logic.de-morgan-propositions open import logic.de-morgan-subtypes +open import logic.double-negation-dense-maps open import logic.double-negation-stable-subtypes ``` @@ -74,18 +72,20 @@ module _ subtype-theorem-Cantor : powerset l2 X subtype-theorem-Cantor x = neg-Prop (f x x) - abstract - not-in-image-subtype-theorem-Cantor : ¬ (fiber f subtype-theorem-Cantor) - not-in-image-subtype-theorem-Cantor (ξ , α) = - no-fixed-points-neg-Prop (f ξ ξ) (iff-eq (htpy-eq α ξ)) + not-in-image-subtype-theorem-Cantor : ¬ (fiber f subtype-theorem-Cantor) + not-in-image-subtype-theorem-Cantor (ξ , α) = + no-fixed-points-neg-Prop (f ξ ξ) (iff-eq (htpy-eq α ξ)) + + theorem-double-negation-dense-Cantor : ¬ (is-double-negation-dense-map f) + theorem-double-negation-dense-Cantor H = + H subtype-theorem-Cantor not-in-image-subtype-theorem-Cantor abstract theorem-Cantor : ¬ (is-surjective f) - theorem-Cantor H = - apply-universal-property-trunc-Prop - ( H subtype-theorem-Cantor) - ( empty-Prop) - ( not-in-image-subtype-theorem-Cantor) + theorem-Cantor = + map-neg + is-double-negation-dense-map-is-surjective + theorem-double-negation-dense-Cantor ``` ### Cantor's theorem for the set of decidable subtypes @@ -101,21 +101,24 @@ module _ map-theorem-decidable-Cantor : decidable-subtype l2 X map-theorem-decidable-Cantor x = neg-Decidable-Prop (f x x) - abstract - not-in-image-map-theorem-decidable-Cantor : - ¬ (fiber f map-theorem-decidable-Cantor) - not-in-image-map-theorem-decidable-Cantor (x , α) = - no-fixed-points-neg-Decidable-Prop - ( f x x) - ( iff-eq (ap prop-Decidable-Prop (htpy-eq α x))) + not-in-image-map-theorem-decidable-Cantor : + ¬ (fiber f map-theorem-decidable-Cantor) + not-in-image-map-theorem-decidable-Cantor (x , α) = + no-fixed-points-neg-Decidable-Prop + ( f x x) + ( iff-eq (ap prop-Decidable-Prop (htpy-eq α x))) + + theorem-double-negation-dense-decidable-Cantor : + ¬ (is-double-negation-dense-map f) + theorem-double-negation-dense-decidable-Cantor H = + H map-theorem-decidable-Cantor not-in-image-map-theorem-decidable-Cantor abstract theorem-decidable-Cantor : ¬ (is-surjective f) - theorem-decidable-Cantor H = - apply-universal-property-trunc-Prop - ( H map-theorem-decidable-Cantor) - ( empty-Prop) - ( not-in-image-map-theorem-decidable-Cantor) + theorem-decidable-Cantor = + map-neg + is-double-negation-dense-map-is-surjective + theorem-double-negation-dense-decidable-Cantor ``` ### Cantor's theorem for the set of double negation stable subtypes @@ -133,21 +136,25 @@ module _ map-theorem-double-negation-stable-Cantor x = neg-Double-Negation-Stable-Prop (f x x) - abstract - not-in-image-map-theorem-double-negation-stable-Cantor : - ¬ (fiber f map-theorem-double-negation-stable-Cantor) - not-in-image-map-theorem-double-negation-stable-Cantor (x , α) = - no-fixed-points-neg-Double-Negation-Stable-Prop - ( f x x) - ( iff-eq (ap prop-Double-Negation-Stable-Prop (htpy-eq α x))) + not-in-image-map-theorem-double-negation-stable-Cantor : + ¬ (fiber f map-theorem-double-negation-stable-Cantor) + not-in-image-map-theorem-double-negation-stable-Cantor (x , α) = + no-fixed-points-neg-Double-Negation-Stable-Prop + ( f x x) + ( iff-eq (ap prop-Double-Negation-Stable-Prop (htpy-eq α x))) + + theorem-double-negation-dense-double-negation-stable-Cantor : + ¬ (is-double-negation-dense-map f) + theorem-double-negation-dense-double-negation-stable-Cantor H = + H map-theorem-double-negation-stable-Cantor + not-in-image-map-theorem-double-negation-stable-Cantor abstract theorem-double-negation-stable-Cantor : ¬ (is-surjective f) - theorem-double-negation-stable-Cantor H = - apply-universal-property-trunc-Prop - ( H map-theorem-double-negation-stable-Cantor) - ( empty-Prop) - ( not-in-image-map-theorem-double-negation-stable-Cantor) + theorem-double-negation-stable-Cantor = + map-neg + is-double-negation-dense-map-is-surjective + theorem-double-negation-dense-double-negation-stable-Cantor ``` ### Cantor's theorem for the set of De Morgan subtypes @@ -163,21 +170,24 @@ module _ map-theorem-de-morgan-Cantor : de-morgan-subtype l2 X map-theorem-de-morgan-Cantor x = neg-De-Morgan-Prop (f x x) - abstract - not-in-image-map-theorem-de-morgan-Cantor : - ¬ (fiber f map-theorem-de-morgan-Cantor) - not-in-image-map-theorem-de-morgan-Cantor (x , α) = - no-fixed-points-neg-De-Morgan-Prop - ( f x x) - ( iff-eq (ap prop-De-Morgan-Prop (htpy-eq α x))) + not-in-image-map-theorem-de-morgan-Cantor : + ¬ (fiber f map-theorem-de-morgan-Cantor) + not-in-image-map-theorem-de-morgan-Cantor (x , α) = + no-fixed-points-neg-De-Morgan-Prop + ( f x x) + ( iff-eq (ap prop-De-Morgan-Prop (htpy-eq α x))) + + theorem-double-negation-dense-de-morgan-Cantor : + ¬ (is-double-negation-dense-map f) + theorem-double-negation-dense-de-morgan-Cantor H = + H map-theorem-de-morgan-Cantor not-in-image-map-theorem-de-morgan-Cantor abstract theorem-de-morgan-Cantor : ¬ (is-surjective f) - theorem-de-morgan-Cantor H = - apply-universal-property-trunc-Prop - ( H map-theorem-de-morgan-Cantor) - ( empty-Prop) - ( not-in-image-map-theorem-de-morgan-Cantor) + theorem-de-morgan-Cantor = + map-neg + is-double-negation-dense-map-is-surjective + theorem-double-negation-dense-de-morgan-Cantor ``` ## References diff --git a/src/foundation/decidable-dependent-function-types.lagda.md b/src/foundation/decidable-dependent-function-types.lagda.md index c63c6ddeea..48da0bfb77 100644 --- a/src/foundation/decidable-dependent-function-types.lagda.md +++ b/src/foundation/decidable-dependent-function-types.lagda.md @@ -7,9 +7,14 @@ module foundation.decidable-dependent-function-types where
Imports ```agda +open import foundation.decidable-propositions open import foundation.decidable-types +open import foundation.dependent-pair-types open import foundation.functoriality-dependent-function-types +open import foundation.irrefutable-equality open import foundation.maybe +open import foundation.mere-equality +open import foundation.propositions open import foundation.uniformly-decidable-type-families open import foundation.universal-property-coproduct-types open import foundation.universal-property-maybe @@ -19,7 +24,8 @@ open import foundation-core.coproduct-types open import foundation-core.empty-types open import foundation-core.equivalences open import foundation-core.function-types -open import foundation-core.negation + +open import logic.propositionally-decidable-types ```
@@ -46,6 +52,28 @@ is-decidable-Π-uniformly-decidable-family (inl a) (inr b) = inr (λ f → b a (f a)) is-decidable-Π-uniformly-decidable-family (inr na) _ = inl (ex-falso ∘ na) + +is-decidable-prop-Π-uniformly-decidable-family : + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} → + is-decidable A → + is-uniformly-decidable-family B → + ((x : A) → is-prop (B x)) → + is-decidable-prop ((a : A) → (B a)) +is-decidable-prop-Π-uniformly-decidable-family dA dB H = + ( is-prop-Π H , is-decidable-Π-uniformly-decidable-family dA dB) + +abstract + is-decidable-prop-Π-uniformly-decidable-family' : + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} → + is-inhabited-or-empty A → + is-uniformly-decidable-family B → + ((x : A) → is-prop (B x)) → + is-decidable-prop ((a : A) → (B a)) + is-decidable-prop-Π-uniformly-decidable-family' {A = A} {B} dA dB H = + elim-is-inhabited-or-empty-Prop' + ( is-decidable-prop-Prop ((a : A) → (B a))) + ( λ d → is-decidable-prop-Π-uniformly-decidable-family d dB H) + ( dA) ``` ### Decidablitilty of dependent products over coproducts @@ -76,6 +104,97 @@ is-decidable-Π-Maybe {B = B} du de = ( is-decidable-product du de) ``` +### Dependent products of decidable propositions over a base with double negation dense equality are decidable propositions + +```agda +module _ + {l1 l2 : Level} {A : UU l1} (B : A → Decidable-Prop l2) + where + + is-decidable-Π-has-double-negation-dense-equality-base : + has-double-negation-dense-equality A → + is-decidable A → + is-decidable ((x : A) → type-Decidable-Prop (B x)) + is-decidable-Π-has-double-negation-dense-equality-base H dA = + is-decidable-Π-uniformly-decidable-family dA + ( is-uniformly-decidable-family-has-double-negation-dense-equality-base + ( H) + ( is-decidable-Decidable-Prop ∘ B) + ( dA)) + + is-decidable-prop-Π-has-double-negation-dense-equality-base : + has-double-negation-dense-equality A → + is-decidable A → + is-decidable-prop ((x : A) → type-Decidable-Prop (B x)) + is-decidable-prop-Π-has-double-negation-dense-equality-base H dA = + is-decidable-prop-Π-uniformly-decidable-family dA + ( is-uniformly-decidable-family-has-double-negation-dense-equality-base + ( H) + ( is-decidable-Decidable-Prop ∘ B) + ( dA)) + ( is-prop-type-Decidable-Prop ∘ B) + + is-decidable-prop-Π-has-double-negation-dense-equality-base' : + has-double-negation-dense-equality A → + is-inhabited-or-empty A → + is-decidable-prop ((x : A) → type-Decidable-Prop (B x)) + is-decidable-prop-Π-has-double-negation-dense-equality-base' H dA = + is-decidable-prop-Π-uniformly-decidable-family' dA + ( is-uniformly-decidable-family-has-double-negation-dense-equality-base' + ( H) + ( is-decidable-Decidable-Prop ∘ B) + ( dA) + ( is-prop-type-Decidable-Prop ∘ B)) + ( is-prop-type-Decidable-Prop ∘ B) +``` + +### Dependent products of decidable propositions over a base with mere equality are decidable propositions + +Assuming the base `A` is empty or 0-connected, a dependent product of decidable +propositions over `A` is again a decidable proposition. + +```agda +module _ + {l1 l2 : Level} {A : UU l1} (B : A → Decidable-Prop l2) + where + + is-decidable-Π-all-elements-merely-equal-base : + all-elements-merely-equal A → + is-decidable A → + is-decidable ((x : A) → type-Decidable-Prop (B x)) + is-decidable-Π-all-elements-merely-equal-base H dA = + is-decidable-Π-uniformly-decidable-family dA + ( is-uniformly-decidable-family-all-elements-merely-equal-base + ( H) + ( is-decidable-Decidable-Prop ∘ B) + ( dA)) + + is-decidable-prop-Π-all-elements-merely-equal-base : + all-elements-merely-equal A → + is-decidable A → + is-decidable-prop ((x : A) → type-Decidable-Prop (B x)) + is-decidable-prop-Π-all-elements-merely-equal-base H dA = + is-decidable-prop-Π-uniformly-decidable-family dA + ( is-uniformly-decidable-family-all-elements-merely-equal-base + ( H) + ( is-decidable-Decidable-Prop ∘ B) + ( dA)) + ( is-prop-type-Decidable-Prop ∘ B) + + is-decidable-prop-Π-all-elements-merely-equal-base' : + all-elements-merely-equal A → + is-inhabited-or-empty A → + is-decidable-prop ((x : A) → type-Decidable-Prop (B x)) + is-decidable-prop-Π-all-elements-merely-equal-base' H dA = + is-decidable-prop-Π-uniformly-decidable-family' dA + ( is-uniformly-decidable-family-all-elements-merely-equal-base' + ( H) + ( is-decidable-Decidable-Prop ∘ B) + ( dA) + ( is-prop-type-Decidable-Prop ∘ B)) + ( is-prop-type-Decidable-Prop ∘ B) +``` + ### Decidability of dependent products over an equivalence ```agda diff --git a/src/foundation/decidable-dependent-pair-types.lagda.md b/src/foundation/decidable-dependent-pair-types.lagda.md index 4af4b5e568..6d80fb78de 100644 --- a/src/foundation/decidable-dependent-pair-types.lagda.md +++ b/src/foundation/decidable-dependent-pair-types.lagda.md @@ -9,7 +9,10 @@ module foundation.decidable-dependent-pair-types where ```agda open import foundation.decidable-types open import foundation.dependent-pair-types +open import foundation.irrefutable-equality open import foundation.maybe +open import foundation.propositional-truncations +open import foundation.transport-along-identifications open import foundation.type-arithmetic-coproduct-types open import foundation.type-arithmetic-unit-type open import foundation.uniformly-decidable-type-families @@ -20,6 +23,8 @@ open import foundation-core.equivalences open import foundation-core.function-types open import foundation-core.functoriality-dependent-pair-types open import foundation-core.negation + +open import logic.propositionally-decidable-types ```
@@ -32,6 +37,21 @@ We describe conditions under which ## Properites +### Decidability of dependent sums over equivalences + +```agda +module _ + {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2} {C : A → UU l3} {D : B → UU l4} + (e : A ≃ B) (f : (x : A) → C x ≃ D (map-equiv e x)) + where + + is-decidable-Σ-equiv : is-decidable (Σ A C) → is-decidable (Σ B D) + is-decidable-Σ-equiv = is-decidable-equiv' (equiv-Σ D e f) + + is-decidable-Σ-equiv' : is-decidable (Σ B D) → is-decidable (Σ A C) + is-decidable-Σ-equiv' = is-decidable-equiv (equiv-Σ D e f) +``` + ### Dependent sums of a uniformly decidable family of types ```agda @@ -66,24 +86,38 @@ is-decidable-Σ-coproduct {A = A} {B} C dA dB = ```agda is-decidable-Σ-Maybe : {l1 l2 : Level} {A : UU l1} {B : Maybe A → UU l2} → - is-decidable (Σ A (B ∘ unit-Maybe)) → is-decidable (B exception-Maybe) → + is-decidable (Σ A (B ∘ unit-Maybe)) → + is-decidable (B exception-Maybe) → is-decidable (Σ (Maybe A) B) is-decidable-Σ-Maybe {A = A} {B} dA de = is-decidable-Σ-coproduct B dA ( is-decidable-equiv (left-unit-law-Σ (B ∘ inr)) de) ``` -### Decidability of dependent sums over equivalences +### Decidability of dependent sums over bases with double negation dense equality ```agda module _ - {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2} {C : A → UU l3} {D : B → UU l4} - (e : A ≃ B) (f : (x : A) → C x ≃ D (map-equiv e x)) + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} + (H : has-double-negation-dense-equality A) where - is-decidable-Σ-equiv : is-decidable (Σ A C) → is-decidable (Σ B D) - is-decidable-Σ-equiv = is-decidable-equiv' (equiv-Σ D e f) - - is-decidable-Σ-equiv' : is-decidable (Σ B D) → is-decidable (Σ A C) - is-decidable-Σ-equiv' = is-decidable-equiv (equiv-Σ D e f) + is-inhabited-or-empty-Σ-has-double-negation-dense-equality-base : + is-inhabited-or-empty A → + ((x : A) → is-inhabited-or-empty (B x)) → + is-inhabited-or-empty (Σ A B) + is-inhabited-or-empty-Σ-has-double-negation-dense-equality-base dA dB = + elim-is-inhabited-or-empty-Prop + ( is-inhabited-or-empty-Prop (Σ A B)) + ( λ a → + elim-is-inhabited-or-empty-Prop + ( is-inhabited-or-empty-Prop (Σ A B)) + ( λ b → inl (unit-trunc-Prop (a , b))) + ( λ nb → inr (λ x → H (pr1 x) a (λ p → nb (tr B p (pr2 x))))) + ( dB a)) + ( λ na → inr (map-neg pr1 na)) + ( dA) ``` + +See [`foundation.decidable-types`](foundation.decidable-types.md) for the +untruncated version. diff --git a/src/foundation/decidable-maps.lagda.md b/src/foundation/decidable-maps.lagda.md index 926253c0dc..fa0d3711df 100644 --- a/src/foundation/decidable-maps.lagda.md +++ b/src/foundation/decidable-maps.lagda.md @@ -13,8 +13,10 @@ open import foundation.coproduct-types open import foundation.decidable-equality open import foundation.decidable-types open import foundation.dependent-pair-types +open import foundation.embeddings open import foundation.functoriality-cartesian-product-types open import foundation.functoriality-coproduct-types +open import foundation.hilbert-epsilon-operators-maps open import foundation.identity-types open import foundation.retracts-of-maps open import foundation.universe-levels @@ -81,14 +83,13 @@ module _ ### Decidable maps are closed under homotopy ```agda -abstract - is-decidable-map-htpy : - {l1 l2 : Level} {A : UU l1} {B : UU l2} {f g : A → B} → - f ~ g → is-decidable-map g → is-decidable-map f - is-decidable-map-htpy H K b = - is-decidable-equiv - ( equiv-tot (λ a → equiv-concat (inv (H a)) b)) - ( K b) +is-decidable-map-htpy : + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f g : A → B} → + f ~ g → is-decidable-map g → is-decidable-map f +is-decidable-map-htpy H K b = + is-decidable-equiv + ( equiv-tot (λ a → equiv-concat (inv (H a)) b)) + ( K b) ``` ### Composition of decidable maps @@ -279,3 +280,32 @@ module _ ( retract-fiber-retract-map f g R x) ( G (map-codomain-inclusion-retract-map f g R x)) ``` + +### Decidable maps have Hilbert ε-operators + +```agda +ε-operator-map-is-decidable-map : + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} → + is-decidable-map f → ε-operator-map f +ε-operator-map-is-decidable-map F = ε-operator-is-decidable ∘ F +``` + +### Decidable injective maps are embeddings + +**Proof.** Given a decidable map `f : A → B` then `f` decomposes +`B ≃ (im f) + B∖(im f)`. Restricting to `im f` we have a section given by the +Hilbert ε-operator on `f`. Now, by injectivity of `f` we know this restriction +map is an equivalence. Hence, by 3-for-2 `f` is also an embedding. + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} + where + + is-emb-is-injective-is-decidable-map : + is-decidable-map f → is-injective f → is-emb f + is-emb-is-injective-is-decidable-map H K = + is-emb-is-injective-ε-operator-map (ε-operator-map-is-decidable-map H) K +``` + +There is also an analogous proof using the double negation image. diff --git a/src/foundation/decidable-propositions.lagda.md b/src/foundation/decidable-propositions.lagda.md index ef885f24e7..a6f6edc2ae 100644 --- a/src/foundation/decidable-propositions.lagda.md +++ b/src/foundation/decidable-propositions.lagda.md @@ -11,8 +11,10 @@ open import foundation-core.decidable-propositions public ```agda open import foundation.action-on-identifications-functions open import foundation.booleans +open import foundation.decidable-equality open import foundation.decidable-types open import foundation.dependent-pair-types +open import foundation.discrete-types open import foundation.embeddings open import foundation.empty-types open import foundation.equivalences @@ -122,15 +124,18 @@ module _ equiv-bool-Decidable-Prop : Decidable-Prop l ≃ bool equiv-bool-Decidable-Prop = equiv-bool-Decidable-Prop' ∘e split-Decidable-Prop + bool-Decidable-Prop : Decidable-Prop l → bool + bool-Decidable-Prop = map-equiv equiv-bool-Decidable-Prop + abstract compute-equiv-bool-Decidable-Prop : (P : Decidable-Prop l) → type-Decidable-Prop P ≃ (map-equiv equiv-bool-Decidable-Prop P ＝ true) - compute-equiv-bool-Decidable-Prop (pair P (pair H (inl p))) = + compute-equiv-bool-Decidable-Prop (P , H , inl p) = equiv-is-contr ( is-proof-irrelevant-is-prop H p) ( is-proof-irrelevant-is-prop (is-set-bool true true) refl) - compute-equiv-bool-Decidable-Prop (pair P (pair H (inr np))) = + compute-equiv-bool-Decidable-Prop (P , H , inr np) = equiv-is-empty np neq-false-true-bool ``` @@ -166,6 +171,21 @@ pr2 (iff-universes-Decidable-Prop l l' P) p = ( p))) ``` +### The type of decidable propositions in any universe is discrete + +```agda +has-decidable-equality-Decidable-Prop : + {l : Level} → has-decidable-equality (Decidable-Prop l) +has-decidable-equality-Decidable-Prop = + has-decidable-equality-equiv + ( equiv-bool-Decidable-Prop) + ( has-decidable-equality-bool) + +Decidable-Prop-Discrete-Type : (l : Level) → Discrete-Type (lsuc l) +Decidable-Prop-Discrete-Type l = + ( Decidable-Prop l , has-decidable-equality-Decidable-Prop) +``` + ### The type of decidable propositions in any universe is a set ```agda diff --git a/src/foundation/decidable-subtypes.lagda.md b/src/foundation/decidable-subtypes.lagda.md index 0bd5ecec7f..fcfc92492a 100644 --- a/src/foundation/decidable-subtypes.lagda.md +++ b/src/foundation/decidable-subtypes.lagda.md @@ -154,14 +154,14 @@ module _ ( is-decidable-emb-map-decidable-emb f) ( y) - compute-type-decidable-type-decidable-emb : + compute-type-decidable-subtype-decidable-emb : type-decidable-subtype decidable-subtype-decidable-emb ≃ X - compute-type-decidable-type-decidable-emb = + compute-type-decidable-subtype-decidable-emb = equiv-total-fiber (map-decidable-emb f) - inv-compute-type-decidable-type-decidable-emb : + inv-compute-type-decidable-subtype-decidable-emb : X ≃ type-decidable-subtype decidable-subtype-decidable-emb - inv-compute-type-decidable-type-decidable-emb = + inv-compute-type-decidable-subtype-decidable-emb = inv-equiv-total-fiber (map-decidable-emb f) ``` diff --git a/src/foundation/decidable-type-families.lagda.md b/src/foundation/decidable-type-families.lagda.md new file mode 100644 index 0000000000..385f928a49 --- /dev/null +++ b/src/foundation/decidable-type-families.lagda.md @@ -0,0 +1,166 @@ +# Decidable families + +```agda +module foundation.decidable-type-families where +``` + +
Imports + +```agda +open import foundation.coproduct-types +open import foundation.decidable-subtypes +open import foundation.decidable-types +open import foundation.dependent-pair-types +open import foundation.double-negation +open import foundation.irrefutable-equality +open import foundation.negation +open import foundation.propositions +open import foundation.transport-along-identifications +open import foundation.universe-levels + +open import foundation-core.function-types +open import foundation-core.identity-types +``` + +
+ +## Idea + +A type family `B : A → 𝒰` is said to be +{{#concept "decidable" Disambiguation="type family" Agda=is-decidable-family}} +if we, for every `x : A`, can either construct an element of `B x`, or we can +prove that it is [empty](foundation-core.empty-types.md). In other words, we +interpret decidability via the +[Curry–Howard interpretation](https://en.wikipedia.org/wiki/Curry–Howard_correspondence) +of logic into type theory. A related concept is that a type family is either +[inhabited](foundation.inhabited-types.md) or empty, where inhabitedness of a +type is expressed using the +[propositional truncation](foundation.propositional-truncations.md). + +## Definitions + +### The Curry–Howard interpretation of decidability + +```agda +is-decidable-family : {l1 l2 : Level} {A : UU l1} (P : A → UU l2) → UU (l1 ⊔ l2) +is-decidable-family {A = A} P = (x : A) → is-decidable (P x) + +decidable-family : {l1 : Level} (l2 : Level) → UU l1 → UU (l1 ⊔ lsuc l2) +decidable-family l2 A = Σ (A → UU l2) is-decidable-family + +module _ + {l1 l2 : Level} {A : UU l1} (P : decidable-family l2 A) + where + + family-decidable-family : A → UU l2 + family-decidable-family = pr1 P + + is-decidable-decidable-family : is-decidable-family family-decidable-family + is-decidable-decidable-family = pr2 P +``` + +### The underlying decidable type family of a decidable subtype + +```agda +decidable-family-decidable-subtype : + {l1 l2 : Level} {A : UU l1} → decidable-subtype l2 A → decidable-family l2 A +decidable-family-decidable-subtype P = + ( is-in-decidable-subtype P , is-decidable-decidable-subtype P) +``` + +## Properties + +### Reindexing decidable type families + +```agda +module _ + {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} (P : decidable-family l3 B) + where + + reindex-decidable-family : (f : A → B) → decidable-family l3 A + reindex-decidable-family f = + ( family-decidable-family P ∘ f , is-decidable-decidable-family P ∘ f) +``` + +### The negation of a decidable family is decidable + +```agda +module _ + {l1 l2 : Level} {A : UU l1} (P : decidable-family l2 A) + where + + is-decidable-neg-decidable-family : + is-decidable-family (¬_ ∘ family-decidable-family P) + is-decidable-neg-decidable-family = + is-decidable-neg ∘ is-decidable-decidable-family P + + neg-decidable-family : decidable-family l2 A + neg-decidable-family = + ( ¬_ ∘ family-decidable-family P , is-decidable-neg-decidable-family) +``` + +### Composition of decidable families + +Given a decidable family of types with double negation dense equality +`P : A → 𝒰` and a decidable type family `Q : (x : A) → P x → 𝒰` then we may +_compose_ `Q` after `P` and obtain a decidabe type family `Q ∘ P : A → 𝒰`. + +```agda +module _ + {l1 l2 l3 : Level} {A : UU l1} + where + + is-decidable-comp-decidable-family-decidable-subtype' : + (P : decidable-family l2 A) + (Q : (x : A) → decidable-family l3 (family-decidable-family P x)) → + ( (x : A) → + has-double-negation-dense-equality (family-decidable-family P x)) → + is-decidable-family + ( λ x → Σ (family-decidable-family P x) (family-decidable-family (Q x))) + is-decidable-comp-decidable-family-decidable-subtype' P Q H x = + rec-coproduct + ( λ p → + rec-coproduct + ( λ q → inl (p , q)) + (λ nq → + inr + ( λ q → + H ( x) + ( p) + ( pr1 q) + ( λ r → + nq (tr (family-decidable-family (Q x)) (inv r) (pr2 q))))) + ( is-decidable-decidable-family (Q x) p)) + (λ np → inr (map-neg pr1 np)) + ( is-decidable-decidable-family P x) + + comp-decidable-family-decidable-subtype' : + (P : decidable-family l2 A) → + ((x : A) → decidable-family l3 (family-decidable-family P x)) → + ( (x : A) → + has-double-negation-dense-equality (family-decidable-family P x)) → + decidable-family (l2 ⊔ l3) A + comp-decidable-family-decidable-subtype' P Q H = + ( λ x → Σ (family-decidable-family P x) (family-decidable-family (Q x))) , + ( is-decidable-comp-decidable-family-decidable-subtype' P Q H) + + comp-decidable-family-decidable-subtype : + (P : decidable-subtype l2 A) → + ((x : A) → decidable-family l3 (is-in-decidable-subtype P x)) → + decidable-family (l2 ⊔ l3) A + comp-decidable-family-decidable-subtype P Q = + comp-decidable-family-decidable-subtype' + ( decidable-family-decidable-subtype P) + ( Q) + ( λ x p q → + intro-double-negation + ( eq-is-prop (is-prop-is-in-decidable-subtype P x))) +``` + +### Decidable families on the subuniverse of propositions + +> TODO + +## See also + +- [Uniformly decidable type families](foundation.uniformly-decidable-type-families.md) diff --git a/src/foundation/decidable-types.lagda.md b/src/foundation/decidable-types.lagda.md index 93bdd1707e..4ab1a9b661 100644 --- a/src/foundation/decidable-types.lagda.md +++ b/src/foundation/decidable-types.lagda.md @@ -13,19 +13,22 @@ open import foundation.dependent-pair-types open import foundation.double-negation open import foundation.empty-types open import foundation.equivalences +open import foundation.evaluation-functions +open import foundation.functoriality-coproduct-types open import foundation.hilberts-epsilon-operators +open import foundation.irrefutable-equality open import foundation.logical-equivalences open import foundation.negation open import foundation.propositional-truncations open import foundation.raising-universe-levels open import foundation.retracts-of-types +open import foundation.transport-along-identifications open import foundation.type-arithmetic-empty-type open import foundation.unit-type open import foundation.universe-levels open import foundation-core.cartesian-product-types open import foundation-core.function-types -open import foundation-core.propositions open import foundation-core.retractions open import foundation-core.sections ``` @@ -45,40 +48,13 @@ of logic into type theory. A related concept is that a type is either type is expressed using the [propositional truncation](foundation.propositional-truncations.md). -## Definition +## Definitions ### The Curry–Howard interpretation of decidability ```agda is-decidable : {l : Level} (A : UU l) → UU l is-decidable A = A + (¬ A) - -is-decidable-fam : - {l1 l2 : Level} {A : UU l1} (P : A → UU l2) → UU (l1 ⊔ l2) -is-decidable-fam {A = A} P = (x : A) → is-decidable (P x) -``` - -### The predicate that a type is inhabited or empty - -```agda -is-inhabited-or-empty : {l1 : Level} → UU l1 → UU l1 -is-inhabited-or-empty A = type-trunc-Prop A + is-empty A -``` - -### Merely decidable types - -A type `A` is said to be -{{#concept "merely decidable" Agda=is-merely-decidable}} if it comes equipped -with an element of `║ is-decidable A ║₋₁`, or equivalently, the -[disjunction](foundation.disjunction.md) `A ∨ ¬ A` holds. - -```agda -is-merely-decidable-Prop : - {l : Level} → UU l → Prop l -is-merely-decidable-Prop A = trunc-Prop (is-decidable A) - -is-merely-decidable : {l : Level} → UU l → UU l -is-merely-decidable A = type-trunc-Prop (is-decidable A) ``` ## Examples @@ -112,7 +88,7 @@ is-decidable-coproduct (inr na) (inr nb) = inr (rec-coproduct na nb) is-decidable-product : {l1 l2 : Level} {A : UU l1} {B : UU l2} → is-decidable A → is-decidable B → is-decidable (A × B) -is-decidable-product (inl a) (inl b) = inl (pair a b) +is-decidable-product (inl a) (inl b) = inl (a , b) is-decidable-product (inl a) (inr g) = inr (g ∘ pr2) is-decidable-product (inr f) (inl b) = inr (f ∘ pr1) is-decidable-product (inr f) (inr g) = inr (f ∘ pr1) @@ -120,22 +96,21 @@ is-decidable-product (inr f) (inr g) = inr (f ∘ pr1) is-decidable-product' : {l1 l2 : Level} {A : UU l1} {B : UU l2} → is-decidable A → (A → is-decidable B) → is-decidable (A × B) -is-decidable-product' (inl a) d with d a -... | inl b = inl (pair a b) -... | inr nb = inr (nb ∘ pr2) +is-decidable-product' (inl a) d = + rec-coproduct (λ b → inl (a , b)) (λ nb → inr (nb ∘ pr2)) (d a) is-decidable-product' (inr na) d = inr (na ∘ pr1) is-decidable-left-factor : {l1 l2 : Level} {A : UU l1} {B : UU l2} → is-decidable (A × B) → B → is-decidable A -is-decidable-left-factor (inl (pair x y)) b = inl x -is-decidable-left-factor (inr f) b = inr (λ a → f (pair a b)) +is-decidable-left-factor (inl (x , y)) b = inl x +is-decidable-left-factor (inr f) b = inr (λ a → f (a , b)) is-decidable-right-factor : {l1 l2 : Level} {A : UU l1} {B : UU l2} → is-decidable (A × B) → A → is-decidable B -is-decidable-right-factor (inl (pair x y)) a = inl y -is-decidable-right-factor (inr f) a = inr (λ b → f (pair a b)) +is-decidable-right-factor (inl (x , y)) a = inl y +is-decidable-right-factor (inr f) a = inr (λ b → f (a , b)) ``` ### Function types of decidable types are decidable @@ -144,16 +119,15 @@ is-decidable-right-factor (inr f) a = inr (λ b → f (pair a b)) is-decidable-function-type : {l1 l2 : Level} {A : UU l1} {B : UU l2} → is-decidable A → is-decidable B → is-decidable (A → B) -is-decidable-function-type (inl a) (inl b) = inl (λ x → b) -is-decidable-function-type (inl a) (inr g) = inr (λ h → g (h a)) +is-decidable-function-type (inl a) (inl b) = inl (λ _ → b) +is-decidable-function-type (inl a) (inr nb) = inr (map-neg (ev a) nb) is-decidable-function-type (inr f) _ = inl (ex-falso ∘ f) is-decidable-function-type' : {l1 l2 : Level} {A : UU l1} {B : UU l2} → is-decidable A → (A → is-decidable B) → is-decidable (A → B) -is-decidable-function-type' (inl a) d with d a -... | inl b = inl (λ x → b) -... | inr nb = inr (λ f → nb (f a)) +is-decidable-function-type' (inl a) d = + rec-coproduct (λ b → inl (λ _ → b)) (λ nb → inr (map-neg (ev a) nb)) (d a) is-decidable-function-type' (inr na) d = inl (ex-falso ∘ na) ``` @@ -165,6 +139,14 @@ is-decidable-neg : is-decidable-neg d = is-decidable-function-type d is-decidable-empty ``` +### The double negation of a decidable type is decidable + +```agda +is-decidable-double-negation : + {l : Level} {A : UU l} → is-decidable A → is-decidable (¬¬ A) +is-decidable-double-negation d = is-decidable-neg (is-decidable-neg d) +``` + ### Decidable types are closed under coinhabited types ```agda @@ -279,38 +261,28 @@ See also ### Decidable types have ε-operators ```agda -elim-trunc-Prop-is-decidable : +ε-operator-is-decidable : {l : Level} {A : UU l} → is-decidable A → ε-operator-Hilbert A -elim-trunc-Prop-is-decidable (inl a) x = a -elim-trunc-Prop-is-decidable (inr f) x = +ε-operator-is-decidable (inl a) x = a +ε-operator-is-decidable (inr f) x = ex-falso (apply-universal-property-trunc-Prop x empty-Prop f) ``` ### `is-decidable` is an idempotent operation ```agda -idempotent-is-decidable : - {l : Level} (P : UU l) → is-decidable (is-decidable P) → is-decidable P -idempotent-is-decidable P (inl (inl p)) = inl p -idempotent-is-decidable P (inl (inr np)) = inr np -idempotent-is-decidable P (inr np) = inr (λ p → np (inl p)) -``` +module _ + {l : Level} {P : UU l} + where -### Being inhabited or empty is a proposition + map-idempotent-is-decidable : is-decidable P → is-decidable (is-decidable P) + map-idempotent-is-decidable = inl -```agda -abstract - is-property-is-inhabited-or-empty : - {l1 : Level} (A : UU l1) → is-prop (is-inhabited-or-empty A) - is-property-is-inhabited-or-empty A = - is-prop-coproduct - ( λ t → apply-universal-property-trunc-Prop t empty-Prop) - ( is-prop-type-trunc-Prop) - ( is-prop-neg) - -is-inhabited-or-empty-Prop : {l1 : Level} → UU l1 → Prop l1 -pr1 (is-inhabited-or-empty-Prop A) = is-inhabited-or-empty A -pr2 (is-inhabited-or-empty-Prop A) = is-property-is-inhabited-or-empty A + map-inv-idempotent-is-decidable : + is-decidable (is-decidable P) → is-decidable P + map-inv-idempotent-is-decidable (inl (inl p)) = inl p + map-inv-idempotent-is-decidable (inl (inr np)) = inr np + map-inv-idempotent-is-decidable (inr np) = inr (λ p → np (inl p)) ``` ### Any inhabited type is a fixed point for `is-decidable` @@ -322,60 +294,32 @@ is-fixed-point-is-decidable-is-inhabited {l} {X} t = right-unit-law-coproduct-is-empty X (¬ X) (is-nonempty-is-inhabited t) ``` -### Raising universe level conserves decidability +### The dependent sum of a family of decidable propositions over a decidable base with double negation dense equality is decidable ```agda -module _ - (l : Level) {l1 : Level} (A : UU l1) - where - - is-decidable-raise : is-decidable A → is-decidable (raise l A) - is-decidable-raise = is-decidable-equiv' (compute-raise l A) +is-decidable-Σ-has-double-negation-dense-equality-base : + {l1 l2 : Level} {P : UU l1} {Q : P → UU l2} → + has-double-negation-dense-equality P → + is-decidable P → + ((x : P) → is-decidable (Q x)) → is-decidable (Σ P Q) +is-decidable-Σ-has-double-negation-dense-equality-base {Q = Q} hP (inl p) dQ = + map-coproduct + ( pair p) + ( λ nq pq → hP (pr1 pq) p (λ r → nq (tr Q r (pr2 pq)))) + ( dQ p) +is-decidable-Σ-has-double-negation-dense-equality-base hP (inr np) _ = + inr (map-neg pr1 np) ``` -### Decidable types are inhabited or empty - -```agda -is-inhabited-or-empty-is-decidable : - {l : Level} {A : UU l} → is-decidable A → is-inhabited-or-empty A -is-inhabited-or-empty-is-decidable (inl x) = inl (unit-trunc-Prop x) -is-inhabited-or-empty-is-decidable (inr y) = inr y -``` - -### Decidable types are merely decidable - -```agda -is-merely-decidable-is-decidable : - {l : Level} {A : UU l} → is-decidable A → is-merely-decidable A -is-merely-decidable-is-decidable = unit-trunc-Prop -``` - -### Types are inhabited or empty if and only if they are merely decidable +### Raising universe level conserves decidability ```agda module _ - {l : Level} {A : UU l} + (l : Level) {l1 : Level} (A : UU l1) where - is-inhabited-or-empty-is-merely-decidable : - is-merely-decidable A → is-inhabited-or-empty A - is-inhabited-or-empty-is-merely-decidable = - rec-trunc-Prop - ( is-inhabited-or-empty-Prop A) - ( is-inhabited-or-empty-is-decidable) - - is-merely-decidable-is-inhabited-or-empty : - is-inhabited-or-empty A → is-merely-decidable A - is-merely-decidable-is-inhabited-or-empty (inl |x|) = - rec-trunc-Prop (is-merely-decidable-Prop A) (unit-trunc-Prop ∘ inl) |x| - is-merely-decidable-is-inhabited-or-empty (inr y) = - unit-trunc-Prop (inr y) - - iff-is-inhabited-or-empty-is-merely-decidable : - is-merely-decidable A ↔ is-inhabited-or-empty A - iff-is-inhabited-or-empty-is-merely-decidable = - ( is-inhabited-or-empty-is-merely-decidable , - is-merely-decidable-is-inhabited-or-empty) + is-decidable-raise : is-decidable A → is-decidable (raise l A) + is-decidable-raise = is-decidable-equiv' (compute-raise l A) ``` ## See also diff --git a/src/foundation/disjoint-subtypes.lagda.md b/src/foundation/disjoint-subtypes.lagda.md index e21739bbd5..77b37edb06 100644 --- a/src/foundation/disjoint-subtypes.lagda.md +++ b/src/foundation/disjoint-subtypes.lagda.md @@ -53,3 +53,7 @@ module _ disjoint-subtype B B → is-empty (type-subtype B) is-empty-disjoint-subtype-self H (b , b∈B) = H b (b∈B , b∈B) ``` + +## See also + +- [Exclusive sums](foundation.exclusive-sum.md) diff --git a/src/foundation/disjunction.lagda.md b/src/foundation/disjunction.lagda.md index 21a764be49..136e6d62f9 100644 --- a/src/foundation/disjunction.lagda.md +++ b/src/foundation/disjunction.lagda.md @@ -22,6 +22,8 @@ open import foundation-core.empty-types open import foundation-core.equivalences open import foundation-core.function-types open import foundation-core.propositions + +open import logic.propositionally-decidable-types ``` @@ -308,7 +310,6 @@ module _ is-decidable A → is-decidable B → is-decidable (disjunction-type A B) is-decidable-disjunction is-decidable-A is-decidable-B = is-decidable-trunc-Prop-is-merely-decidable - ( A + B) ( unit-trunc-Prop (is-decidable-coproduct is-decidable-A is-decidable-B)) module _ diff --git a/src/foundation/double-negation-dense-equality-maps.lagda.md b/src/foundation/double-negation-dense-equality-maps.lagda.md new file mode 100644 index 0000000000..86b0e049c6 --- /dev/null +++ b/src/foundation/double-negation-dense-equality-maps.lagda.md @@ -0,0 +1,35 @@ +# Maps with double negation dense equality + +```agda +module foundation.double-negation-dense-equality-maps where +``` + +
Imports + +```agda +open import foundation.irrefutable-equality +open import foundation.universe-levels + +open import foundation-core.fibers-of-maps +``` + +
+ +## Idea + +A map `f : A → B` is said to have +{{#concept "double negation dense equality" Disambiguation="map of types" Agda=has-double-negation-dense-equality-map}} +if its [fibers](foundation-core.fibers-of-maps.md) have +[double negation dense equality](foundation.irrefutable-equality.md). I.e., if +for every `y : B` and every pair `p q : fiber f y` it is +[irrefutable](foundation.irrefutable-propositions.md) that `p` equals `q`. In +other words, `¬¬ (p ＝ q)` holds. + +## Definitions + +```agda +has-double-negation-dense-equality-map : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → (A → B) → UU (l1 ⊔ l2) +has-double-negation-dense-equality-map {B = B} f = + (y : B) → has-double-negation-dense-equality (fiber f y) +``` diff --git a/src/foundation/double-negation-images.lagda.md b/src/foundation/double-negation-images.lagda.md new file mode 100644 index 0000000000..c6c10ecf79 --- /dev/null +++ b/src/foundation/double-negation-images.lagda.md @@ -0,0 +1,299 @@ +# The double negation image of a map + +```agda +module foundation.double-negation-images where +``` + +
Imports + +```agda +open import foundation.action-on-identifications-functions +open import foundation.dependent-pair-types +open import foundation.double-negation +open import foundation.embeddings +open import foundation.fundamental-theorem-of-identity-types +open import foundation.hilbert-epsilon-operators-maps +open import foundation.slice +open import foundation.split-surjective-maps +open import foundation.subtype-identity-principle +open import foundation.universe-levels + +open import foundation-core.1-types +open import foundation-core.commuting-triangles-of-maps +open import foundation-core.equivalences +open import foundation-core.fibers-of-maps +open import foundation-core.identity-types +open import foundation-core.injective-maps +open import foundation-core.propositions +open import foundation-core.sets +open import foundation-core.subtypes +open import foundation-core.torsorial-type-families +open import foundation-core.truncated-types +open import foundation-core.truncation-levels + +open import logic.double-negation-dense-maps +open import logic.double-negation-eliminating-maps +open import logic.double-negation-stable-embeddings +``` + +
+ +## Idea + +The +{{#concept "double negation image" Disambiguation="of a map" Agda=double-negation-im}} +of `f : A → B` is the essentially unique type that factorizes `f` as a +[double negation dense map](logic.double-negation-dense-maps.md) followed by a +[double negation stable embedding](logic.double-negation-stable-embeddings.md). + +## Definitions + +```agda +module _ + {l1 l2 : Level} {X : UU l1} {A : UU l2} (f : A → X) + where + + subtype-double-negation-im : subtype (l1 ⊔ l2) X + subtype-double-negation-im x = double-negation-type-Prop (fiber f x) + + is-in-double-negation-im : X → UU (l1 ⊔ l2) + is-in-double-negation-im = is-in-subtype subtype-double-negation-im + + double-negation-im : UU (l1 ⊔ l2) + double-negation-im = type-subtype subtype-double-negation-im + + inclusion-double-negation-im : double-negation-im → X + inclusion-double-negation-im = inclusion-subtype subtype-double-negation-im + + map-unit-double-negation-im : A → double-negation-im + map-unit-double-negation-im a = (f a , intro-double-negation (a , refl)) + + triangle-unit-double-negation-im : + coherence-triangle-maps + ( f) + ( inclusion-double-negation-im) + ( map-unit-double-negation-im) + triangle-unit-double-negation-im a = refl + + unit-double-negation-im : hom-slice f inclusion-double-negation-im + pr1 unit-double-negation-im = map-unit-double-negation-im + pr2 unit-double-negation-im = triangle-unit-double-negation-im +``` + +## Properties + +### We characterize the identity type of `double-negation-im f` + +```agda +module _ + {l1 l2 : Level} {X : UU l1} {A : UU l2} (f : A → X) + where + + Eq-double-negation-im : double-negation-im f → double-negation-im f → UU l1 + Eq-double-negation-im x y = (pr1 x ＝ pr1 y) + + refl-Eq-double-negation-im : + (x : double-negation-im f) → Eq-double-negation-im x x + refl-Eq-double-negation-im x = refl + + Eq-eq-double-negation-im : + (x y : double-negation-im f) → x ＝ y → Eq-double-negation-im x y + Eq-eq-double-negation-im x .x refl = refl-Eq-double-negation-im x + + abstract + is-torsorial-Eq-double-negation-im : + (x : double-negation-im f) → is-torsorial (Eq-double-negation-im x) + is-torsorial-Eq-double-negation-im x = + is-torsorial-Eq-subtype + ( is-torsorial-Id (pr1 x)) + ( is-prop-is-in-subtype (subtype-double-negation-im f)) + ( pr1 x) + ( refl) + ( pr2 x) + + abstract + is-equiv-Eq-eq-double-negation-im : + (x y : double-negation-im f) → is-equiv (Eq-eq-double-negation-im x y) + is-equiv-Eq-eq-double-negation-im x = + fundamental-theorem-id + ( is-torsorial-Eq-double-negation-im x) + ( Eq-eq-double-negation-im x) + + equiv-Eq-eq-double-negation-im : + (x y : double-negation-im f) → (x ＝ y) ≃ Eq-double-negation-im x y + equiv-Eq-eq-double-negation-im x y = + ( Eq-eq-double-negation-im x y , is-equiv-Eq-eq-double-negation-im x y) + + eq-Eq-double-negation-im : + (x y : double-negation-im f) → Eq-double-negation-im x y → x ＝ y + eq-Eq-double-negation-im x y = + map-inv-equiv (equiv-Eq-eq-double-negation-im x y) +``` + +### The unit map of the double negation image is double negation dense + +```agda +abstract + is-double-negation-dense-unit-double-negation-im : + {l1 l2 : Level} {A : UU l1} {B : UU l2} (f : A → B) → + is-double-negation-dense-map (map-unit-double-negation-im f) + is-double-negation-dense-unit-double-negation-im f (y , nnq) np = + nnq + ( λ p → + np + ( pr1 p , + eq-Eq-double-negation-im f + ( map-unit-double-negation-im f (pr1 p)) (y , nnq) (pr2 p))) +``` + +### The double negation image inclusion is a double negation stable embedding + +```agda +module _ + {l1 l2 : Level} {X : UU l1} {A : UU l2} (f : A → X) + where + + is-emb-inclusion-double-negation-im : + is-emb (inclusion-double-negation-im f) + is-emb-inclusion-double-negation-im = + is-emb-inclusion-subtype (subtype-double-negation-im f) + + emb-double-negation-im : double-negation-im f ↪ X + emb-double-negation-im = + ( inclusion-double-negation-im f , is-emb-inclusion-double-negation-im) + + is-injective-inclusion-double-negation-im : + is-injective (inclusion-double-negation-im f) + is-injective-inclusion-double-negation-im = + is-injective-is-emb is-emb-inclusion-double-negation-im + + is-double-negation-eliminating-map-inclusion-double-negation-im : + is-double-negation-eliminating-map (inclusion-double-negation-im f) + is-double-negation-eliminating-map-inclusion-double-negation-im x nnip = + ( ( x , + ( λ np → + nnip + ( λ ip → + is-double-negation-dense-unit-double-negation-im f + ( pr1 ip) + ( λ ηq → + np + ( pr1 ηq , + ap (inclusion-double-negation-im f) (pr2 ηq) ∙ pr2 ip))))) , + ( refl)) + + double-negation-eliminating-map-inclusion-double-negation-im : + double-negation-im f →¬¬ X + double-negation-eliminating-map-inclusion-double-negation-im = + ( inclusion-double-negation-im f , + is-double-negation-eliminating-map-inclusion-double-negation-im) + + is-double-negation-stable-emb-inclusion-double-negation-im : + is-double-negation-stable-emb (inclusion-double-negation-im f) + is-double-negation-stable-emb-inclusion-double-negation-im = + ( is-emb-inclusion-double-negation-im , + is-double-negation-eliminating-map-inclusion-double-negation-im) + + double-negation-stable-emb-double-negation-im : double-negation-im f ↪¬¬ X + double-negation-stable-emb-double-negation-im = + ( inclusion-double-negation-im f , + is-double-negation-stable-emb-inclusion-double-negation-im) + + ε-operator-map-inclusion-double-negation-im : + ε-operator-map (inclusion-double-negation-im f) + ε-operator-map-inclusion-double-negation-im = + ε-operator-double-negation-eliminating-map + ( double-negation-eliminating-map-inclusion-double-negation-im) +``` + +### The double negation image of a map into a truncated type is truncated + +```agda +abstract + is-trunc-double-negation-im : + {l1 l2 : Level} (k : 𝕋) {X : UU l1} {A : UU l2} (f : A → X) → + is-trunc (succ-𝕋 k) X → is-trunc (succ-𝕋 k) (double-negation-im f) + is-trunc-double-negation-im k f = is-trunc-emb k (emb-double-negation-im f) + +double-negation-im-Truncated-Type : + {l1 l2 : Level} (k : 𝕋) (X : Truncated-Type l1 (succ-𝕋 k)) {A : UU l2} + (f : A → type-Truncated-Type X) → Truncated-Type (l1 ⊔ l2) (succ-𝕋 k) +double-negation-im-Truncated-Type k X f = + ( double-negation-im f , + is-trunc-double-negation-im k f (is-trunc-type-Truncated-Type X)) +``` + +### The double negation image of a map into a proposition is a proposition + +```agda +abstract + is-prop-double-negation-im : + {l1 l2 : Level} {X : UU l1} {A : UU l2} (f : A → X) → + is-prop X → is-prop (double-negation-im f) + is-prop-double-negation-im = is-trunc-double-negation-im neg-two-𝕋 + +double-negation-im-Prop : + {l1 l2 : Level} (X : Prop l1) {A : UU l2} + (f : A → type-Prop X) → Prop (l1 ⊔ l2) +double-negation-im-Prop = double-negation-im-Truncated-Type neg-two-𝕋 +``` + +### The double negation image of a map into a set is a set + +```agda +abstract + is-set-double-negation-im : + {l1 l2 : Level} {X : UU l1} {A : UU l2} (f : A → X) → + is-set X → is-set (double-negation-im f) + is-set-double-negation-im = is-trunc-double-negation-im neg-one-𝕋 + +double-negation-im-Set : + {l1 l2 : Level} (X : Set l1) {A : UU l2} + (f : A → type-Set X) → Set (l1 ⊔ l2) +double-negation-im-Set = double-negation-im-Truncated-Type (neg-one-𝕋) +``` + +### The double negation image of a map into a 1-type is a 1-type + +```agda +abstract + is-1-type-double-negation-im : + {l1 l2 : Level} {X : UU l1} {A : UU l2} (f : A → X) → + is-1-type X → is-1-type (double-negation-im f) + is-1-type-double-negation-im = is-trunc-double-negation-im zero-𝕋 + +double-negation-im-1-Type : + {l1 l2 : Level} (X : 1-Type l1) {A : UU l2} + (f : A → type-1-Type X) → 1-Type (l1 ⊔ l2) +double-negation-im-1-Type = double-negation-im-Truncated-Type zero-𝕋 +``` + +### Injective double negation eliminating maps are embeddings + +```agda +module _ + {l1 l2 : Level} {X : UU l1} {A : UU l2} {f : A → X} + where + + is-emb-is-injective-is-double-negation-eliminating-map : + is-double-negation-eliminating-map f → is-injective f → is-emb f + is-emb-is-injective-is-double-negation-eliminating-map K H = + is-emb-comp + ( inclusion-double-negation-im f) + ( map-unit-double-negation-im f) + ( is-emb-inclusion-double-negation-im f) + ( is-emb-is-equiv + ( is-equiv-is-split-surjective-is-injective + ( map-unit-double-negation-im f) + ( is-injective-right-factor + ( inclusion-double-negation-im f) + ( map-unit-double-negation-im f) H) + ( λ x → + pr1 (K (pr1 x) (pr2 x)) , + is-injective-inclusion-double-negation-im f + ( pr2 (K (pr1 x) (pr2 x)))))) +``` + +## See also + +- [The double negation modality](foundation.double-negation-modality.md) diff --git a/src/foundation/double-negation-stable-propositions.lagda.md b/src/foundation/double-negation-stable-propositions.lagda.md index 0ba325bf24..b3486593b7 100644 --- a/src/foundation/double-negation-stable-propositions.lagda.md +++ b/src/foundation/double-negation-stable-propositions.lagda.md @@ -8,27 +8,20 @@ module foundation.double-negation-stable-propositions where ```agda open import foundation.cartesian-product-types -open import foundation.conjunction -open import foundation.coproduct-types open import foundation.decidable-propositions open import foundation.decidable-types open import foundation.dependent-pair-types -open import foundation.disjunction open import foundation.double-negation open import foundation.embeddings open import foundation.empty-types open import foundation.equivalences -open import foundation.existential-quantification open import foundation.logical-equivalences open import foundation.negation open import foundation.propositional-extensionality open import foundation.propositions open import foundation.sets open import foundation.subtypes -open import foundation.transport-along-identifications -open import foundation.type-arithmetic-dependent-pair-types open import foundation.unit-type -open import foundation.universal-quantification open import foundation.universe-levels open import foundation-core.contractible-types @@ -283,6 +276,20 @@ neg-Double-Negation-Stable-Prop P = neg-type-Double-Negation-Stable-Prop (type-Double-Negation-Stable-Prop P) ``` +### Double negations of types are double negation stable propositions + +```agda +double-negation-type-Double-Negation-Stable-Prop : + {l : Level} → UU l → Double-Negation-Stable-Prop l +double-negation-type-Double-Negation-Stable-Prop A = + neg-Double-Negation-Stable-Prop (neg-type-Double-Negation-Stable-Prop A) + +double-negation-Double-Negation-Stable-Prop : + {l : Level} → Double-Negation-Stable-Prop l → Double-Negation-Stable-Prop l +double-negation-Double-Negation-Stable-Prop P = + neg-Double-Negation-Stable-Prop (neg-Double-Negation-Stable-Prop P) +``` + ### Universal quantification over double negation stable propositions is double negation stable ```agda @@ -292,7 +299,7 @@ is-double-negation-stable-prop-Π : is-double-negation-stable-prop ((a : A) → B a) is-double-negation-stable-prop-Π b = ( is-prop-Π (is-prop-type-is-double-negation-stable-prop ∘ b)) , - ( double-negation-elim-for-all + ( double-negation-elim-Π ( has-double-negation-elim-is-double-negation-stable-prop ∘ b)) Π-Double-Negation-Stable-Prop : diff --git a/src/foundation/double-negation.lagda.md b/src/foundation/double-negation.lagda.md index ee813f6384..5ecc842912 100644 --- a/src/foundation/double-negation.lagda.md +++ b/src/foundation/double-negation.lagda.md @@ -42,6 +42,9 @@ intro-double-negation p f = f p map-double-negation : {l1 l2 : Level} {P : UU l1} {Q : UU l2} → (P → Q) → ¬¬ P → ¬¬ Q map-double-negation f = map-neg (map-neg f) + +elim-triple-negation : {l : Level} {P : UU l} → ¬¬¬ P → ¬ P +elim-triple-negation = map-neg intro-double-negation ``` ## Properties @@ -94,23 +97,28 @@ double-negation-linearity-implication {P = P} {Q = Q} f = ### Maps into double negations extend along `intro-double-negation` ```agda -double-negation-extend : +extend-double-negation : {l1 l2 : Level} {P : UU l1} {Q : UU l2} → (P → ¬¬ Q) → (¬¬ P → ¬¬ Q) -double-negation-extend {P = P} {Q = Q} f nnp nq = nnp (λ p → f p nq) +extend-double-negation {P = P} {Q = Q} f nnp nq = nnp (λ p → f p nq) ``` ### The double negation of a type is logically equivalent to the double negation of its propositional truncation ```agda +abstract + intro-double-negation-type-trunc-Prop : + {l : Level} {A : UU l} → type-trunc-Prop A → ¬¬ A + intro-double-negation-type-trunc-Prop {A = A} = + map-universal-property-trunc-Prop + ( double-negation-type-Prop A) + ( intro-double-negation) + abstract double-negation-double-negation-type-trunc-Prop : - {l : Level} (A : UU l) → ¬¬ (type-trunc-Prop A) → ¬¬ A - double-negation-double-negation-type-trunc-Prop A = - double-negation-extend - ( map-universal-property-trunc-Prop - ( double-negation-type-Prop A) - ( intro-double-negation)) + {l : Level} {A : UU l} → ¬¬ (type-trunc-Prop A) → ¬¬ A + double-negation-double-negation-type-trunc-Prop = + extend-double-negation intro-double-negation-type-trunc-Prop abstract double-negation-type-trunc-Prop-double-negation : diff --git a/src/foundation/full-subtypes.lagda.md b/src/foundation/full-subtypes.lagda.md index 57a9714080..6392c181e5 100644 --- a/src/foundation/full-subtypes.lagda.md +++ b/src/foundation/full-subtypes.lagda.md @@ -36,7 +36,7 @@ module _ where is-full-subtype-Prop : Prop (l1 ⊔ l2) - is-full-subtype-Prop = Π-Prop A (λ x → P x) + is-full-subtype-Prop = Π-Prop A P is-full-subtype : UU (l1 ⊔ l2) is-full-subtype = type-Prop is-full-subtype-Prop diff --git a/src/foundation/hilbert-epsilon-operators-maps.lagda.md b/src/foundation/hilbert-epsilon-operators-maps.lagda.md new file mode 100644 index 0000000000..1c7dbdbbfd --- /dev/null +++ b/src/foundation/hilbert-epsilon-operators-maps.lagda.md @@ -0,0 +1,93 @@ +# Hilbert ε-operators on maps + +```agda +module foundation.hilbert-epsilon-operators-maps where +``` + +
Imports + +```agda +open import foundation.dependent-pair-types +open import foundation.embeddings +open import foundation.hilberts-epsilon-operators +open import foundation.images +open import foundation.universe-levels + +open import foundation-core.equivalences +open import foundation-core.fibers-of-maps +open import foundation-core.injective-maps +open import foundation-core.sections +``` + +
+ +## Idea + +A +{{#concept "Hilbert ε-operator" Disambiguation="on a map" Agda=ε-operator-map}} +on a map $f : A → B$ is a family of +[Hilbert ε-operators](foundation.hilberts-epsilon-operators.md) on its +[fibers](foundation-core.fibers-of-maps.md). I.e., for every `y : B` there is an +operator + +```text + ε_y : ║ fiber f y ║₋₁ → fiber f y. +``` + +Some authors also refer to this as _split support_ {{#cite KECA17}}. Contrary to +Hilbert, we do not assume that such an operator exists for every map. + +## Definitions + +### The structure of a Hilbert ε-operator on a map + +```agda +ε-operator-map : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → (A → B) → UU (l1 ⊔ l2) +ε-operator-map {B = B} f = (y : B) → ε-operator-Hilbert (fiber f y) +``` + +## Properties + +### ε-operators on maps are sections of the image-unit + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} + where + + map-section-map-unit-im-ε-operator-map : ε-operator-map f → im f → A + map-section-map-unit-im-ε-operator-map ε (y , p) = pr1 (ε y p) + + is-section-map-section-map-unit-im-ε-operator-map : + (ε : ε-operator-map f) → + is-section (map-unit-im f) (map-section-map-unit-im-ε-operator-map ε) + is-section-map-section-map-unit-im-ε-operator-map ε (y , p) = + eq-Eq-im f _ _ (pr2 (ε y p)) + + section-map-unit-im-ε-operator-map : + ε-operator-map f → section (map-unit-im f) + section-map-unit-im-ε-operator-map ε = + ( map-section-map-unit-im-ε-operator-map ε , + is-section-map-section-map-unit-im-ε-operator-map ε) +``` + +### Injective maps with ε-operators are embeddings + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} + where + + is-emb-is-injective-ε-operator-map : + ε-operator-map f → is-injective f → is-emb f + is-emb-is-injective-ε-operator-map ε H = + is-emb-comp + ( inclusion-im f) + ( map-unit-im f) + ( is-emb-inclusion-im f) + ( is-emb-is-equiv + ( is-equiv-is-injective + ( section-map-unit-im-ε-operator-map ε) + ( is-injective-right-factor (inclusion-im f) (map-unit-im f) H))) +``` diff --git a/src/foundation/hilberts-epsilon-operators.lagda.md b/src/foundation/hilberts-epsilon-operators.lagda.md index 1c23904a8b..476596058c 100644 --- a/src/foundation/hilberts-epsilon-operators.lagda.md +++ b/src/foundation/hilberts-epsilon-operators.lagda.md @@ -1,4 +1,4 @@ -# Hilbert's `ε`-operators +# Hilbert's ε-operators ```agda module foundation.hilberts-epsilon-operators where @@ -19,7 +19,8 @@ open import foundation-core.function-types ## Idea -{{#concept "Hilbert's $ε$-operator"}} at a type `A` is a map +{{#concept "Hilbert's ε-operator" Disambiguation="on types" Agda=ε-operator-Hilbert}} +on a type `A` is a map ```text ε : ║A║₋₁ → A diff --git a/src/foundation/images-subtypes.lagda.md b/src/foundation/images-subtypes.lagda.md index f2959311bd..fc716d0cc9 100644 --- a/src/foundation/images-subtypes.lagda.md +++ b/src/foundation/images-subtypes.lagda.md @@ -252,7 +252,7 @@ module _ has-same-elements-subtype (subtype-im (g ∘ f)) (im-subtype g (subtype-im f)) compute-subtype-im-comp x = logical-equivalence-reasoning - is-in-subtype-im (g ∘ f) x + is-in-im (g ∘ f) x ↔ is-in-im-subtype (g ∘ f) (full-subtype lzero A) x by inv-iff (compute-im-full-subtype (g ∘ f) x) diff --git a/src/foundation/images.lagda.md b/src/foundation/images.lagda.md index 4ffd596c45..7fdbb46a83 100644 --- a/src/foundation/images.lagda.md +++ b/src/foundation/images.lagda.md @@ -17,7 +17,6 @@ open import foundation.universe-levels open import foundation-core.1-types open import foundation-core.commuting-triangles-of-maps -open import foundation-core.contractible-types open import foundation-core.embeddings open import foundation-core.equivalences open import foundation-core.fibers-of-maps @@ -52,8 +51,8 @@ module _ subtype-im : subtype (l1 ⊔ l2) X subtype-im x = trunc-Prop (fiber f x) - is-in-subtype-im : X → UU (l1 ⊔ l2) - is-in-subtype-im = is-in-subtype subtype-im + is-in-im : X → UU (l1 ⊔ l2) + is-in-im = is-in-subtype subtype-im im : UU (l1 ⊔ l2) im = type-subtype subtype-im diff --git a/src/foundation/inequality-booleans.lagda.md b/src/foundation/inequality-booleans.lagda.md new file mode 100644 index 0000000000..48c3f4f6ad --- /dev/null +++ b/src/foundation/inequality-booleans.lagda.md @@ -0,0 +1,226 @@ +# The standard inequality relation on booleans + +```agda +module foundation.inequality-booleans where +``` + +
Imports + +```agda +open import foundation.booleans +open import foundation.decidable-propositions +open import foundation.decidable-types +open import foundation.dependent-pair-types +open import foundation.disjunction +open import foundation.logical-operations-booleans +open import foundation.propositional-truncations +open import foundation.unit-type +open import foundation.universe-levels + +open import foundation-core.coproduct-types +open import foundation-core.identity-types +open import foundation-core.propositions + +open import order-theory.decidable-total-orders +open import order-theory.posets +open import order-theory.preorders +open import order-theory.total-orders +``` + +
+ +## Idea + +The +{{#concept "standard inequality relation" Disambiguation="on booleans" Agda=}} +on [booleans](foundation.booleans.md) is the inductively defined +[relation](foundation.binary-relations.md) given by the four inequalities + +```text + false ≤ false + false ≤ true + true ≤ true + true ≰ false. +``` + +## Definitions + +### The standard inequality relation on booleans + +```agda +leq-bool-Decidable-Prop : bool → bool → Decidable-Prop lzero +leq-bool-Decidable-Prop x y = decidable-prop-bool (hom-bool x y) + +leq-bool-Prop : bool → bool → Prop lzero +leq-bool-Prop x y = prop-Decidable-Prop (leq-bool-Decidable-Prop x y) + +leq-bool : bool → bool → UU lzero +leq-bool x y = type-Decidable-Prop (leq-bool-Decidable-Prop x y) + +is-decidable-leq-bool : {x y : bool} → is-decidable (leq-bool x y) +is-decidable-leq-bool {x} {y} = + is-decidable-Decidable-Prop (leq-bool-Decidable-Prop x y) + +is-prop-leq-bool : {x y : bool} → is-prop (leq-bool x y) +is-prop-leq-bool {x} {y} = is-prop-type-Prop (leq-bool-Prop x y) +``` + +## Properties + +### Reflexivity + +```agda +refl-leq-bool : {x : bool} → leq-bool x x +refl-leq-bool {true} = star +refl-leq-bool {false} = star + +refl-leq-bool' : (x : bool) → leq-bool x x +refl-leq-bool' x = refl-leq-bool {x} + +leq-eq-bool : {x y : bool} → x ＝ y → leq-bool x y +leq-eq-bool {x} refl = refl-leq-bool' x +``` + +### Transitivity + +```agda +transitive-leq-bool : + {x y z : bool} → leq-bool y z → leq-bool x y → leq-bool x z +transitive-leq-bool {true} {true} {true} p q = star +transitive-leq-bool {false} {y} {z} p q = star +``` + +### Antisymmetry + +```agda +antisymmetric-leq-bool : + {x y : bool} → leq-bool x y → leq-bool y x → x ＝ y +antisymmetric-leq-bool {true} {true} p q = refl +antisymmetric-leq-bool {false} {false} p q = refl +``` + +### Linearity + +```agda +linear-leq-bool : {x y : bool} → leq-bool x y + leq-bool y x +linear-leq-bool {true} {true} = inr star +linear-leq-bool {true} {false} = inr star +linear-leq-bool {false} {y} = inl star + +is-total-leq-bool : + (x y : bool) → disjunction-type (leq-bool x y) (leq-bool y x) +is-total-leq-bool x y = unit-trunc-Prop (linear-leq-bool {x} {y}) +``` + +### The maximal and minimal elements + +```agda +leq-true-bool : {x : bool} → leq-bool x true +leq-true-bool {true} = star +leq-true-bool {false} = star + +leq-false-bool : {x : bool} → leq-bool false x +leq-false-bool = star + +eq-leq-true-bool : {x : bool} → leq-bool true x → x ＝ true +eq-leq-true-bool {true} p = refl + +eq-leq-false-bool : {x : bool} → leq-bool x false → x ＝ false +eq-leq-false-bool {false} p = refl +``` + +### The decidable total order on booleans + +```agda +bool-Preorder : Preorder lzero lzero +bool-Preorder = + ( bool , + leq-bool-Prop , + refl-leq-bool' , + ( λ x y z → transitive-leq-bool {x} {y} {z})) + +bool-Poset : Poset lzero lzero +bool-Poset = (bool-Preorder , (λ x y → antisymmetric-leq-bool {x} {y})) + +bool-Total-Order : Total-Order lzero lzero +bool-Total-Order = (bool-Poset , is-total-leq-bool) + +bool-Decidable-Total-Order : Decidable-Total-Order lzero lzero +bool-Decidable-Total-Order = + ( bool-Poset , + ( is-total-leq-bool) , + ( λ x y → is-decidable-Decidable-Prop (leq-bool-Decidable-Prop x y))) +``` + +### Interactions between the inequality relation and the disjunction operation + +```agda +leq-or-bool : {x y : bool} → leq-bool x (or-bool x y) +leq-or-bool {true} {y} = star +leq-or-bool {false} {y} = star + +leq-or-bool' : {x y : bool} → leq-bool y (or-bool x y) +leq-or-bool' {true} {true} = star +leq-or-bool' {true} {false} = star +leq-or-bool' {false} {true} = star +leq-or-bool' {false} {false} = star + +leq-left-or-bool : {x y : bool} → leq-bool x y → leq-bool (or-bool x y) y +leq-left-or-bool {true} {true} p = star +leq-left-or-bool {false} {true} p = star +leq-left-or-bool {false} {false} p = star + +leq-right-or-bool : {x y : bool} → leq-bool x y → leq-bool (or-bool y x) y +leq-right-or-bool {x} {true} p = star +leq-right-or-bool {false} {false} p = star + +leq-or-bool'' : + {x y z : bool} → leq-bool x z → leq-bool y z → leq-bool (or-bool x y) z +leq-or-bool'' {true} {y} {true} p q = star +leq-or-bool'' {false} {true} {true} p q = star +leq-or-bool'' {false} {false} {true} p q = star +leq-or-bool'' {false} {false} {false} p q = star +``` + +### Interactions between the inequality relation and the conjunction operation + +```agda +leq-and-bool : {x y : bool} → leq-bool (and-bool x y) x +leq-and-bool {true} {true} = star +leq-and-bool {false} {true} = star +leq-and-bool {true} {false} = star +leq-and-bool {false} {false} = star + +leq-and-bool' : {x y : bool} → leq-bool (and-bool x y) y +leq-and-bool' {true} {true} = star +leq-and-bool' {true} {false} = star +leq-and-bool' {false} {y} = star + +leq-left-and-bool : {x y : bool} → leq-bool x y → leq-bool x (and-bool x y) +leq-left-and-bool {true} {true} p = star +leq-left-and-bool {false} {y} p = star + +leq-right-and-bool : {x y : bool} → leq-bool x y → leq-bool x (and-bool y x) +leq-right-and-bool {true} {true} p = star +leq-right-and-bool {false} {y} p = star + +leq-and-bool'' : + {x y z : bool} → leq-bool x y → leq-bool x z → leq-bool x (and-bool y z) +leq-and-bool'' {true} {true} {true} p q = star +leq-and-bool'' {false} {y} {z} p q = star +``` + +```agda +is-false-is-false-leq-bool : + {x y : bool} → leq-bool x y → is-false y → is-false x +is-false-is-false-leq-bool {false} {false} p refl = refl + +is-true-is-true-leq-bool : + {x y : bool} → leq-bool x y → is-true x → is-true y +is-true-is-true-leq-bool {true} {true} p refl = refl +``` + +## See also + +- The underlying category of the poset of booleans is called + [the representing arrow category](category-theory.representing-arrow-category.md). diff --git a/src/foundation/injective-maps.lagda.md b/src/foundation/injective-maps.lagda.md index 8ab3913353..56aff7be4a 100644 --- a/src/foundation/injective-maps.lagda.md +++ b/src/foundation/injective-maps.lagda.md @@ -9,7 +9,6 @@ open import foundation-core.injective-maps public
Imports ```agda -open import foundation.action-on-identifications-dependent-functions open import foundation.action-on-identifications-functions open import foundation.dependent-pair-types open import foundation.function-extensionality @@ -33,7 +32,8 @@ open import foundation-core.sets ## Idea -A map `f : A → B` is **injective** if `f x ＝ f y` implies `x ＝ y`. +A map `f : A → B` is **injective**, also called _left cancellable_, if +`f x ＝ f y` implies `x ＝ y`. ## Warning diff --git a/src/foundation/irrefutable-propositions.lagda.md b/src/foundation/irrefutable-propositions.lagda.md index a6a0d7fcde..6cd2618c29 100644 --- a/src/foundation/irrefutable-propositions.lagda.md +++ b/src/foundation/irrefutable-propositions.lagda.md @@ -9,20 +9,15 @@ module foundation.irrefutable-propositions where ```agda open import foundation.cartesian-product-types open import foundation.contractible-types -open import foundation.coproduct-types open import foundation.decidable-propositions -open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.double-negation -open import foundation.empty-types open import foundation.function-types -open import foundation.negation open import foundation.propositions open import foundation.subuniverses -open import foundation.unit-type open import foundation.universe-levels -open import logic.double-negation-elimination +open import logic.irrefutable-types ```
@@ -30,7 +25,8 @@ open import logic.double-negation-elimination ## Idea The [subuniverse](foundation.subuniverses.md) of -{{#concept "irrefutable propositions" Agda=Irrefutable-Prop}} consists of +{{#concept "irrefutable propositions" Agda=Irrefutable-Prop}}, or **double +negation dense propositions**, consists of [propositions](foundation-core.propositions.md) `P` for which the [double negation](foundation.double-negation.md) `¬¬P` is true. @@ -43,14 +39,11 @@ module _ {l : Level} (P : Prop l) where - is-irrefutable : UU l - is-irrefutable = ¬¬ (type-Prop P) - - is-prop-is-irrefutable : is-prop is-irrefutable - is-prop-is-irrefutable = is-prop-double-negation - is-irrefutable-Prop : Prop l - is-irrefutable-Prop = double-negation-Prop P + is-irrefutable-Prop = is-irrefutable-prop-Type (type-Prop P) + + is-irrefutable-type-Prop : UU l + is-irrefutable-type-Prop = is-irrefutable (type-Prop P) ``` ### The predicate on a type of being an irrefutable proposition @@ -81,7 +74,7 @@ module _ prop-is-irrefutable-prop = P , is-prop-type-is-irrefutable-prop is-irrefutable-is-irrefutable-prop : - is-irrefutable (P , is-prop-type-is-irrefutable-prop) + is-irrefutable P is-irrefutable-is-irrefutable-prop = pr2 H ``` @@ -92,7 +85,7 @@ Irrefutable-Prop : (l : Level) → UU (lsuc l) Irrefutable-Prop l = type-subuniverse is-irrefutable-prop-Prop make-Irrefutable-Prop : - {l : Level} (P : Prop l) → is-irrefutable P → Irrefutable-Prop l + {l : Level} (P : Prop l) → is-irrefutable-type-Prop P → Irrefutable-Prop l make-Irrefutable-Prop P is-irrefutable-P = ( type-Prop P , is-prop-type-Prop P , is-irrefutable-P) @@ -114,60 +107,31 @@ module _ prop-Irrefutable-Prop : Prop l prop-Irrefutable-Prop = type-Irrefutable-Prop , is-prop-type-Irrefutable-Prop - is-irrefutable-Irrefutable-Prop : is-irrefutable prop-Irrefutable-Prop + is-irrefutable-Irrefutable-Prop : is-irrefutable type-Irrefutable-Prop is-irrefutable-Irrefutable-Prop = is-irrefutable-is-irrefutable-prop is-irrefutable-prop-type-Irrefutable-Prop ``` ## Properties -### Provable propositions are irrefutable - -```agda -module _ - {l : Level} (P : Prop l) - where - - is-irrefutable-has-element : type-Prop P → is-irrefutable P - is-irrefutable-has-element = intro-double-negation - -is-irrefutable-unit : is-irrefutable unit-Prop -is-irrefutable-unit = is-irrefutable-has-element unit-Prop star -``` - ### Contractible types are irrefutable propositions ```agda is-irrefutable-prop-is-contr : {l : Level} {P : UU l} → is-contr P → is-irrefutable-prop P is-irrefutable-prop-is-contr H = - ( is-prop-is-contr H , intro-double-negation (center H)) -``` - -### If it is irrefutable that a proposition is irrefutable, then the proposition is irrefutable - -```agda -module _ - {l : Level} (P : Prop l) - where - - is-idempotent-is-irrefutable : - is-irrefutable (is-irrefutable-Prop P) → is-irrefutable P - is-idempotent-is-irrefutable = - double-negation-elim-neg (¬ (type-Prop P)) + ( is-prop-is-contr H , is-irrefutable-is-contr H) ``` ### Decidability is irrefutable ```agda -is-irrefutable-is-decidable : {l : Level} {A : UU l} → ¬¬ (is-decidable A) -is-irrefutable-is-decidable H = H (inr (H ∘ inl)) - module _ {l : Level} (P : Prop l) where - is-irrefutable-is-decidable-Prop : is-irrefutable (is-decidable-Prop P) + is-irrefutable-is-decidable-Prop : + is-irrefutable-type-Prop (is-decidable-Prop P) is-irrefutable-is-decidable-Prop = is-irrefutable-is-decidable is-decidable-prop-Irrefutable-Prop : Irrefutable-Prop l @@ -175,15 +139,6 @@ module _ make-Irrefutable-Prop (is-decidable-Prop P) is-irrefutable-is-decidable-Prop ``` -### Double negation elimination is irrefutable - -```agda -is-irrefutable-double-negation-elim : - {l : Level} {A : UU l} → ¬¬ (has-double-negation-elim A) -is-irrefutable-double-negation-elim H = - H (λ f → ex-falso (f (λ a → H (λ _ → a)))) -``` - ### Dependent sums of irrefutable propositions ```agda @@ -191,10 +146,6 @@ module _ {l1 l2 : Level} {A : UU l1} {B : A → UU l2} where - is-irrefutable-Σ : - ¬¬ A → ((x : A) → ¬¬ B x) → ¬¬ (Σ A B) - is-irrefutable-Σ nna nnb nab = nna (λ a → nnb a (λ b → nab (a , b))) - is-irrefutable-prop-Σ : is-irrefutable-prop A → ((x : A) → is-irrefutable-prop (B x)) → is-irrefutable-prop (Σ A B) @@ -214,28 +165,11 @@ module _ {l1 l2 : Level} {A : UU l1} {B : UU l2} where - is-irrefutable-product : ¬¬ A → ¬¬ B → ¬¬ (A × B) - is-irrefutable-product nna nnb = is-irrefutable-Σ nna (λ _ → nnb) - is-irrefutable-prop-product : is-irrefutable-prop A → is-irrefutable-prop B → is-irrefutable-prop (A × B) is-irrefutable-prop-product a b = is-irrefutable-prop-Σ a (λ _ → b) ``` -### Coproducts of irrefutable propositions - -```agda -module _ - {l1 l2 : Level} {A : UU l1} {B : UU l2} - where - - is-irrefutable-coproduct-inl : ¬¬ A → ¬¬ (A + B) - is-irrefutable-coproduct-inl nna x = nna (x ∘ inl) - - is-irrefutable-coproduct-inr : ¬¬ B → ¬¬ (A + B) - is-irrefutable-coproduct-inr nnb x = nnb (x ∘ inr) -``` - ## See also - [De Morgan's law](logic.de-morgans-law.md) is irrefutable. diff --git a/src/foundation/limited-principle-of-omniscience.lagda.md b/src/foundation/limited-principle-of-omniscience.lagda.md index e66cea9ad0..de2a9feed7 100644 --- a/src/foundation/limited-principle-of-omniscience.lagda.md +++ b/src/foundation/limited-principle-of-omniscience.lagda.md @@ -12,17 +12,12 @@ open import elementary-number-theory.natural-numbers open import foundation.booleans open import foundation.coproduct-types open import foundation.dependent-pair-types -open import foundation.disjunction open import foundation.existential-quantification open import foundation.negation open import foundation.universal-quantification open import foundation.universe-levels -open import foundation-core.identity-types open import foundation-core.propositions -open import foundation-core.sets - -open import univalent-combinatorics.standard-finite-types ``` @@ -55,7 +50,7 @@ is-prop-LPO = is-prop-coproduct ( elim-exists ( ¬' ∀' ℕ (λ n → is-false-Prop (f n))) - ( λ n t h → not-is-false-is-true (f n) t (h n))) + ( λ n t h → is-not-false-is-true (f n) t (h n))) ( is-prop-exists ℕ (λ n → is-true-Prop (f n))) ( is-prop-for-all-Prop ℕ (λ n → is-false-Prop (f n)))) diff --git a/src/foundation/logical-operations-booleans.lagda.md b/src/foundation/logical-operations-booleans.lagda.md new file mode 100644 index 0000000000..b0818af5f1 --- /dev/null +++ b/src/foundation/logical-operations-booleans.lagda.md @@ -0,0 +1,297 @@ +# Logical operations on the booleans + +```agda +module foundation.logical-operations-booleans where +``` + +
Imports + +```agda +open import foundation.apartness-relations +open import foundation.booleans +open import foundation.decidable-equality +open import foundation.decidable-types +open import foundation.dependent-pair-types +open import foundation.discrete-types +open import foundation.involutions +open import foundation.negated-equality +open import foundation.raising-universe-levels +open import foundation.tight-apartness-relations +open import foundation.unit-type +open import foundation.universe-levels + +open import foundation-core.constant-maps +open import foundation-core.coproduct-types +open import foundation-core.decidable-propositions +open import foundation-core.empty-types +open import foundation-core.equivalences +open import foundation-core.function-types +open import foundation-core.homotopies +open import foundation-core.identity-types +open import foundation-core.injective-maps +open import foundation-core.negation +open import foundation-core.propositions +open import foundation-core.sections +open import foundation-core.sets + +open import univalent-combinatorics.finite-types +open import univalent-combinatorics.standard-finite-types +``` + +
+ +## Idea + +We consider basic logical operations on the booleans and prove standard facts +about them. + +## Definitions + +### Negation + +```agda +neg-bool : bool → bool +neg-bool true = false +neg-bool false = true +``` + +### Conjunction + +```agda +and-bool : bool → bool → bool +and-bool true y = y +and-bool false y = false +``` + +### Disjunction + +```agda +or-bool : bool → bool → bool +or-bool true y = true +or-bool false y = y +``` + +### Implication + +```agda +hom-bool : bool → bool → bool +hom-bool x = or-bool (neg-bool x) +``` + +### Exclusive disjunction + +```agda +xor-bool : bool → bool → bool +xor-bool true y = neg-bool y +xor-bool false y = y +``` + +### Negated exclusive disjunction + +```agda +xnor-bool : bool → bool → bool +xnor-bool true y = y +xnor-bool false y = neg-bool y +``` + +## Properties + +### Boolean negation has no fixed points + +```agda +neq-neg-bool : (b : bool) → b ≠ neg-bool b +neq-neg-bool true () +neq-neg-bool false () + +neq-neg-bool' : (b : bool) → neg-bool b ≠ b +neq-neg-bool' b = neq-neg-bool b ∘ inv + +is-true-is-false-neg-bool : {b : bool} → is-false (neg-bool b) → is-true b +is-true-is-false-neg-bool {true} p = refl + +is-false-is-true-neg-bool : {b : bool} → is-true (neg-bool b) → is-false b +is-false-is-true-neg-bool {false} p = refl +``` + +### Boolean negation is an involution + +```agda +is-involution-neg-bool : is-involution neg-bool +is-involution-neg-bool true = refl +is-involution-neg-bool false = refl +``` + +### Boolean negation is an equivalence + +```agda +abstract + is-equiv-neg-bool : is-equiv neg-bool + is-equiv-neg-bool = is-equiv-is-involution is-involution-neg-bool + +equiv-neg-bool : bool ≃ bool +pr1 equiv-neg-bool = neg-bool +pr2 equiv-neg-bool = is-equiv-neg-bool +``` + +### Basic properties of the or operation + +```agda +left-unit-law-or-bool : {x : bool} → or-bool false x ＝ x +left-unit-law-or-bool = refl + +right-unit-law-or-bool : {x : bool} → or-bool x false ＝ x +right-unit-law-or-bool {true} = refl +right-unit-law-or-bool {false} = refl + +left-zero-law-or-bool : {x : bool} → or-bool true x ＝ true +left-zero-law-or-bool = refl + +right-zero-law-or-bool : {x : bool} → or-bool x true ＝ true +right-zero-law-or-bool {true} = refl +right-zero-law-or-bool {false} = refl + +idempotent-or-bool : {x : bool} → or-bool x x ＝ x +idempotent-or-bool {true} = refl +idempotent-or-bool {false} = refl + +commutative-or-bool : {x y : bool} → or-bool x y ＝ or-bool y x +commutative-or-bool {true} {true} = refl +commutative-or-bool {true} {false} = refl +commutative-or-bool {false} {true} = refl +commutative-or-bool {false} {false} = refl + +associative-or-bool : + {x y z : bool} → or-bool (or-bool x y) z ＝ or-bool x (or-bool y z) +associative-or-bool {true} {y} {z} = refl +associative-or-bool {false} {y} {z} = refl +``` + +### Basic properties of the and operation + +```agda +left-unit-law-and-bool : {x : bool} → and-bool true x ＝ x +left-unit-law-and-bool = refl + +right-unit-law-and-bool : {x : bool} → and-bool x true ＝ x +right-unit-law-and-bool {true} = refl +right-unit-law-and-bool {false} = refl + +left-zero-law-and-bool : {x : bool} → and-bool false x ＝ false +left-zero-law-and-bool = refl + +right-zero-law-and-bool : {x : bool} → and-bool x false ＝ false +right-zero-law-and-bool {true} = refl +right-zero-law-and-bool {false} = refl + +commutative-and-bool : {x y : bool} → and-bool x y ＝ and-bool y x +commutative-and-bool {true} {true} = refl +commutative-and-bool {true} {false} = refl +commutative-and-bool {false} {true} = refl +commutative-and-bool {false} {false} = refl + +idempotent-and-bool : {x : bool} → and-bool x x ＝ x +idempotent-and-bool {true} = refl +idempotent-and-bool {false} = refl + +associative-and-bool : + {x y z : bool} → and-bool (and-bool x y) z ＝ and-bool x (and-bool y z) +associative-and-bool {true} {y} {z} = refl +associative-and-bool {false} {y} {z} = refl +``` + +### Basic properties of the implication operation + +```agda +left-unit-law-hom-bool : {x : bool} → hom-bool true x ＝ x +left-unit-law-hom-bool = refl + +right-neg-law-hom-bool : {x : bool} → hom-bool x false ＝ neg-bool x +right-neg-law-hom-bool {true} = refl +right-neg-law-hom-bool {false} = refl + +left-zero-law-hom-bool : {x : bool} → hom-bool false x ＝ true +left-zero-law-hom-bool = refl + +right-zero-law-hom-bool : {x : bool} → hom-bool x true ＝ true +right-zero-law-hom-bool {true} = refl +right-zero-law-hom-bool {false} = refl + +compute-hom-self-bool : {x : bool} → hom-bool x x ＝ true +compute-hom-self-bool {true} = refl +compute-hom-self-bool {false} = refl +``` + +### Computing implication on connectives + +```agda +compute-and-hom-bool : + {x y z : bool} → hom-bool (and-bool x y) z ＝ hom-bool x (hom-bool y z) +compute-and-hom-bool {true} {y} {z} = refl +compute-and-hom-bool {false} {y} {z} = refl + +compute-or-hom-bool : + {x y z : bool} → + hom-bool (or-bool x y) z ＝ and-bool (hom-bool x z) (hom-bool y z) +compute-or-hom-bool {true} {true} {true} = refl +compute-or-hom-bool {true} {false} {true} = refl +compute-or-hom-bool {true} {true} {false} = refl +compute-or-hom-bool {true} {false} {false} = refl +compute-or-hom-bool {false} {y} {z} = refl + +distributive-hom-and-bool : + {x y z : bool} → + hom-bool x (and-bool y z) ＝ and-bool (hom-bool x y) (hom-bool x z) +distributive-hom-and-bool {true} {y} {z} = refl +distributive-hom-and-bool {false} {y} {z} = refl +``` + +### Distributivity of conjunction over disjunction + +```agda +distributive-and-or-bool : + {x y z : bool} → + and-bool x (or-bool y z) ＝ or-bool (and-bool x y) (and-bool x z) +distributive-and-or-bool {true} = refl +distributive-and-or-bool {false} = refl +``` + +### Distributivity of disjunction over conjunction + +```agda +distributive-or-and-bool : + {x y z : bool} → + or-bool x (and-bool y z) ＝ and-bool (or-bool x y) (or-bool x z) +distributive-or-and-bool {true} = refl +distributive-or-and-bool {false} = refl +``` + +### The law of excluded middle + +```agda +law-of-excluded-middle-bool : + {x : bool} → or-bool x (neg-bool x) ＝ true +law-of-excluded-middle-bool {true} = refl +law-of-excluded-middle-bool {false} = refl +``` + +### Double negation elimination + +```agda +double-negation-elim-bool : {x : bool} → neg-bool (neg-bool x) ＝ x +double-negation-elim-bool {true} = refl +double-negation-elim-bool {false} = refl +``` + +### De Morgan's laws + +```agda +de-morgans-law-bool : + {x y : bool} → neg-bool (and-bool x y) ＝ or-bool (neg-bool x) (neg-bool y) +de-morgans-law-bool {true} = refl +de-morgans-law-bool {false} = refl + +de-morgans-law-bool' : + {x y : bool} → neg-bool (or-bool x y) ＝ and-bool (neg-bool x) (neg-bool y) +de-morgans-law-bool' {true} = refl +de-morgans-law-bool' {false} = refl +``` diff --git a/src/foundation/null-homotopic-maps.lagda.md b/src/foundation/null-homotopic-maps.lagda.md index 2500c019f4..7c91dd99e8 100644 --- a/src/foundation/null-homotopic-maps.lagda.md +++ b/src/foundation/null-homotopic-maps.lagda.md @@ -11,27 +11,21 @@ open import foundation.commuting-triangles-of-identifications open import foundation.constant-maps open import foundation.dependent-pair-types open import foundation.empty-types -open import foundation.functoriality-dependent-pair-types open import foundation.fundamental-theorem-of-identity-types open import foundation.homotopy-induction open import foundation.identity-types -open import foundation.images open import foundation.inhabited-types -open import foundation.negation open import foundation.propositional-truncations open import foundation.propositions open import foundation.sets open import foundation.structure-identity-principle open import foundation.torsorial-type-families open import foundation.type-arithmetic-dependent-pair-types -open import foundation.unit-type open import foundation.universal-property-empty-type open import foundation.universe-levels open import foundation.weakly-constant-maps -open import foundation-core.contractible-types open import foundation-core.equivalences -open import foundation-core.function-types open import foundation-core.homotopies ``` diff --git a/src/foundation/path-split-type-families.lagda.md b/src/foundation/path-split-type-families.lagda.md index 690d6d1a74..54af7a8822 100644 --- a/src/foundation/path-split-type-families.lagda.md +++ b/src/foundation/path-split-type-families.lagda.md @@ -36,7 +36,7 @@ and `v` _over_ p. This condition is [equivalent](foundation.logical-equivalences.md) to asking that `P` is a family of [propositions](foundation-core.propositions.md). -This condition is a direct rephrasing of stating that the +This condition is a direct rephrasing of the statement that the [action on identifications](foundation.action-on-identifications-functions.md) of the first projection map `Σ A P → A` has a [section](foundation-core.sections.md), and in this way is closely related to diff --git a/src/foundation/projective-types.lagda.md b/src/foundation/projective-types.lagda.md index f537366853..4ac853ef0d 100644 --- a/src/foundation/projective-types.lagda.md +++ b/src/foundation/projective-types.lagda.md @@ -15,7 +15,6 @@ open import foundation.surjective-maps open import foundation.truncation-levels open import foundation.universe-levels -open import foundation-core.function-types open import foundation-core.sets open import foundation-core.truncated-types ``` @@ -76,5 +75,5 @@ is-projective l2 l3 k X = ## See also -- The natural map `(X → A)/~ → (X → A/R)` was studied in - [foundation.exponents-set-quotients](foundation.exponents-set-quotients.md) +- The natural map `(X → A)/~ → (X → A/R)` is studied in + [`foundation.exponents-set-quotients`](foundation.exponents-set-quotients.md) diff --git a/src/foundation/propositional-truncations.lagda.md b/src/foundation/propositional-truncations.lagda.md index 2ae3713137..9888a5f5aa 100644 --- a/src/foundation/propositional-truncations.lagda.md +++ b/src/foundation/propositional-truncations.lagda.md @@ -8,6 +8,7 @@ module foundation.propositional-truncations where ```agda open import foundation.action-on-identifications-functions +open import foundation.constant-type-families open import foundation.dependent-pair-types open import foundation.functoriality-cartesian-product-types open import foundation.logical-equivalences @@ -19,6 +20,7 @@ open import foundation.universe-levels open import foundation-core.cartesian-product-types open import foundation-core.contractible-types open import foundation-core.coproduct-types +open import foundation-core.dependent-identifications open import foundation-core.equivalences open import foundation-core.function-types open import foundation-core.identity-types @@ -46,22 +48,22 @@ postulate of the existence of truncations at all levels, found in the file type-trunc-Prop : {l : Level} → UU l → UU l type-trunc-Prop = type-trunc neg-one-𝕋 -unit-trunc-Prop : {l : Level} {A : UU l} → A → type-trunc-Prop A +║_║₋₁ : {l : Level} → UU l → UU l +║_║₋₁ = type-trunc-Prop + +unit-trunc-Prop : {l : Level} {A : UU l} → A → ║ A ║₋₁ unit-trunc-Prop = unit-trunc -is-prop-type-trunc-Prop : {l : Level} {A : UU l} → is-prop (type-trunc-Prop A) +is-prop-type-trunc-Prop : {l : Level} {A : UU l} → is-prop (║ A ║₋₁) is-prop-type-trunc-Prop = is-trunc-type-trunc all-elements-equal-type-trunc-Prop : - {l : Level} {A : UU l} → all-elements-equal (type-trunc-Prop A) + {l : Level} {A : UU l} → all-elements-equal (║ A ║₋₁) all-elements-equal-type-trunc-Prop {l} {A} = eq-is-prop' (is-prop-type-trunc-Prop {l} {A}) trunc-Prop : {l : Level} → UU l → Prop l trunc-Prop = trunc neg-one-𝕋 - -║_║₋₁ : {l : Level} → UU l → UU l -║_║₋₁ = type-trunc-Prop ``` **Notation.** The [box drawings double vertical](https://codepoints.net/U+2551) @@ -76,10 +78,10 @@ the list. ```agda abstract is-prop-condition-ind-trunc-Prop' : - {l1 l2 : Level} {A : UU l1} {P : type-trunc-Prop A → UU l2} → - ( (x y : type-trunc-Prop A) (u : P x) (v : P y) → - tr P (all-elements-equal-type-trunc-Prop x y) u ＝ v) → - (x : type-trunc-Prop A) → is-prop (P x) + {l1 l2 : Level} {A : UU l1} {P : ║ A ║₋₁ → UU l2} → + ( (x y : ║ A ║₋₁) (u : P x) (v : P y) → + dependent-identification P (all-elements-equal-type-trunc-Prop x y) u v) → + (x : ║ A ║₋₁) → is-prop (P x) is-prop-condition-ind-trunc-Prop' {P = P} H x = is-prop-all-elements-equal ( λ u v → @@ -93,29 +95,46 @@ abstract ```agda ind-trunc-Prop' : - {l l1 : Level} {A : UU l1} (P : type-trunc-Prop A → UU l) + {l l1 : Level} {A : UU l1} (P : ║ A ║₋₁ → UU l) (f : (x : A) → P (unit-trunc-Prop x)) (H : - (x y : type-trunc-Prop A) (u : P x) (v : P y) → - tr P (all-elements-equal-type-trunc-Prop x y) u ＝ v) → - (x : type-trunc-Prop A) → P x + (x y : ║ A ║₋₁) (u : P x) (v : P y) → + dependent-identification P (all-elements-equal-type-trunc-Prop x y) u v) → + (x : ║ A ║₋₁) → P x ind-trunc-Prop' P f H = function-dependent-universal-property-trunc - ( λ x → pair (P x) (is-prop-condition-ind-trunc-Prop' H x)) + ( λ x → (P x , is-prop-condition-ind-trunc-Prop' H x)) ( f) ``` +### The recursion principle for propositional truncations + +```agda +rec-trunc-Prop' : + {l l1 : Level} {A : UU l1} {P : UU l} + (f : A → P) (H : ║ A ║₋₁ → (u v : P) → u ＝ v) → + ║ A ║₋₁ → P +rec-trunc-Prop' {P = P} f H = + ind-trunc-Prop' + ( λ _ → P) + ( f) + ( λ x y u v → + map-compute-dependent-identification-constant-type-family + ( all-elements-equal-type-trunc-Prop x y) + ( H x u v)) +``` + ### The propositional induction principle for propositional truncations ```agda module _ - {l l1 : Level} {A : UU l1} (P : type-trunc-Prop A → Prop l) + {l l1 : Level} {A : UU l1} (P : ║ A ║₋₁ → Prop l) where abstract ind-trunc-Prop : ((x : A) → type-Prop (P (unit-trunc-Prop x))) → - (( y : type-trunc-Prop A) → type-Prop (P y)) + (( y : ║ A ║₋₁) → type-Prop (P y)) ind-trunc-Prop f = ind-trunc-Prop' (type-Prop ∘ P) f ( λ x y u v → eq-is-prop (is-prop-type-Prop (P y))) @@ -135,7 +154,7 @@ module _ abstract rec-trunc-Prop : - (A → type-Prop P) → (type-trunc-Prop A → type-Prop P) + (A → type-Prop P) → (║ A ║₋₁ → type-Prop P) rec-trunc-Prop = ind-trunc-Prop (λ _ → P) compute-rec-trunc-Prop : @@ -186,15 +205,15 @@ abstract abstract apply-universal-property-trunc-Prop : - {l1 l2 : Level} {A : UU l1} (t : type-trunc-Prop A) (P : Prop l2) → + {l1 l2 : Level} {A : UU l1} (t : ║ A ║₋₁) (P : Prop l2) → (A → type-Prop P) → type-Prop P apply-universal-property-trunc-Prop t P f = map-universal-property-trunc-Prop P f t abstract apply-twice-universal-property-trunc-Prop : - {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} (u : type-trunc-Prop A) - (v : type-trunc-Prop B) (P : Prop l3) → + {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} (u : ║ A ║₋₁) + (v : ║ B ║₋₁) (P : Prop l3) → (A → B → type-Prop P) → type-Prop P apply-twice-universal-property-trunc-Prop u v P f = apply-universal-property-trunc-Prop u P @@ -203,7 +222,7 @@ abstract abstract apply-three-times-universal-property-trunc-Prop : {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2} {C : UU l3} - (u : type-trunc-Prop A) (v : type-trunc-Prop B) (w : type-trunc-Prop C) → + (u : ║ A ║₋₁) (v : ║ B ║₋₁) (w : ║ C ║₋₁) → (P : Prop l4) → (A → B → C → type-Prop P) → type-Prop P apply-three-times-universal-property-trunc-Prop u v w P f = apply-universal-property-trunc-Prop u P @@ -214,12 +233,12 @@ abstract ```agda is-trunc-trunc-Prop : - {l : Level} (k : 𝕋) {A : UU l} → is-trunc (succ-𝕋 k) (type-trunc-Prop A) + {l : Level} (k : 𝕋) {A : UU l} → is-trunc (succ-𝕋 k) (║ A ║₋₁) is-trunc-trunc-Prop k = is-trunc-is-prop k is-prop-type-trunc-Prop truncated-type-trunc-Prop : {l : Level} (k : 𝕋) → UU l → Truncated-Type l (succ-𝕋 k) -pr1 (truncated-type-trunc-Prop k A) = type-trunc-Prop A +pr1 (truncated-type-trunc-Prop k A) = ║ A ║₋₁ pr2 (truncated-type-trunc-Prop k A) = is-trunc-trunc-Prop k set-trunc-Prop : {l : Level} → UU l → Set l @@ -233,7 +252,7 @@ module _ {l : Level} (A : Prop l) where - equiv-unit-trunc-Prop : type-Prop A ≃ type-trunc-Prop (type-Prop A) + equiv-unit-trunc-Prop : type-Prop A ≃ ║ type-Prop A ║₋₁ equiv-unit-trunc-Prop = equiv-unit-trunc A ``` @@ -246,7 +265,7 @@ module _ abstract map-idempotent-trunc-Prop : - type-trunc-Prop (type-trunc-Prop A) → type-trunc-Prop A + ║ (║ A ║₋₁) ║₋₁ → ║ A ║₋₁ map-idempotent-trunc-Prop = map-universal-property-trunc-Prop (trunc-Prop A) id @@ -259,13 +278,13 @@ module _ ( unit-trunc-Prop) idempotent-trunc-Prop : - type-trunc-Prop (type-trunc-Prop A) ≃ type-trunc-Prop A + ║ (║ A ║₋₁) ║₋₁ ≃ ║ A ║₋₁ pr1 idempotent-trunc-Prop = map-idempotent-trunc-Prop pr2 idempotent-trunc-Prop = is-equiv-map-idempotent-trunc-Prop abstract is-equiv-map-inv-idempotent-trunc-Prop : - is-equiv (unit-trunc-Prop {A = type-trunc-Prop A}) + is-equiv (unit-trunc-Prop {A = ║ A ║₋₁}) is-equiv-map-inv-idempotent-trunc-Prop = is-equiv-has-converse-is-prop ( is-prop-type-trunc-Prop) @@ -273,7 +292,7 @@ module _ ( map-idempotent-trunc-Prop) inv-idempotent-trunc-Prop : - type-trunc-Prop A ≃ type-trunc-Prop (type-trunc-Prop A) + ║ A ║₋₁ ≃ ║ (║ A ║₋₁) ║₋₁ pr1 inv-idempotent-trunc-Prop = unit-trunc-Prop pr2 inv-idempotent-trunc-Prop = is-equiv-map-inv-idempotent-trunc-Prop ``` @@ -294,11 +313,11 @@ abstract ( is-propositional-truncation-trunc-Prop A) module _ - {l1 l2 : Level} {A : UU l1} (P : type-trunc-Prop A → Prop l2) + {l1 l2 : Level} {A : UU l1} (P : ║ A ║₋₁ → Prop l2) where equiv-dependent-universal-property-trunc-Prop : - ((y : type-trunc-Prop A) → type-Prop (P y)) ≃ + ((y : ║ A ║₋₁) → type-Prop (P y)) ≃ ((x : A) → type-Prop (P (unit-trunc-Prop x))) pr1 equiv-dependent-universal-property-trunc-Prop = precomp-Π unit-trunc-Prop (type-Prop ∘ P) @@ -306,7 +325,7 @@ module _ dependent-universal-property-trunc-Prop P apply-dependent-universal-property-trunc-Prop : - (y : type-trunc-Prop A) → ((x : A) → type-Prop (P (unit-trunc-Prop x))) → + (y : ║ A ║₋₁) → ((x : A) → type-Prop (P (unit-trunc-Prop x))) → type-Prop (P y) apply-dependent-universal-property-trunc-Prop y f = map-inv-equiv equiv-dependent-universal-property-trunc-Prop f y @@ -339,17 +358,17 @@ equiv-product-trunc-Prop A A' = map-distributive-trunc-product-Prop : {l1 l2 : Level} {A : UU l1} {B : UU l2} → - type-trunc-Prop (A × B) → type-trunc-Prop A × type-trunc-Prop B + ║ A × B ║₋₁ → ║ A ║₋₁ × ║ B ║₋₁ map-distributive-trunc-product-Prop {l1} {l2} {A} {B} = map-universal-property-trunc-Prop ( pair - ( type-trunc-Prop A × type-trunc-Prop B) + ( ║ A ║₋₁ × ║ B ║₋₁) ( is-prop-product is-prop-type-trunc-Prop is-prop-type-trunc-Prop)) ( map-product unit-trunc-Prop unit-trunc-Prop) map-inv-distributive-trunc-product-Prop : {l1 l2 : Level} {A : UU l1} {B : UU l2} → - type-trunc-Prop A × type-trunc-Prop B → type-trunc-Prop (A × B) + ║ A ║₋₁ × ║ B ║₋₁ → ║ A × B ║₋₁ map-inv-distributive-trunc-product-Prop {l1} {l2} {A} {B} t = map-universal-property-trunc-Prop ( trunc-Prop (A × B)) @@ -372,7 +391,7 @@ abstract distributive-trunc-product-Prop : {l1 l2 : Level} {A : UU l1} {B : UU l2} → - type-trunc-Prop (A × B) ≃ (type-trunc-Prop A × type-trunc-Prop B) + ║ A × B ║₋₁ ≃ ║ A ║₋₁ × ║ B ║₋₁ pr1 distributive-trunc-product-Prop = map-distributive-trunc-product-Prop pr2 distributive-trunc-product-Prop = is-equiv-map-distributive-trunc-product-Prop @@ -389,7 +408,7 @@ abstract inv-distributive-trunc-product-Prop : {l1 l2 : Level} {A : UU l1} {B : UU l2} → - ( type-trunc-Prop A × type-trunc-Prop B) ≃ type-trunc-Prop (A × B) + ( ║ A ║₋₁ × ║ B ║₋₁) ≃ ║ A × B ║₋₁ pr1 inv-distributive-trunc-product-Prop = map-inv-distributive-trunc-product-Prop pr2 inv-distributive-trunc-product-Prop = @@ -400,16 +419,18 @@ pr2 inv-distributive-trunc-product-Prop = ```agda module _ - {l : Level} {A : UU l} where + {l : Level} {A : UU l} + where + map-trunc-Prop-diagonal-coproduct : - type-trunc-Prop (A + A) → type-trunc-Prop A + ║ A + A ║₋₁ → ║ A ║₋₁ map-trunc-Prop-diagonal-coproduct = map-universal-property-trunc-Prop ( trunc-Prop A) ( unit-trunc ∘ rec-coproduct id id) map-inv-trunc-Prop-diagonal-coproduct : - type-trunc-Prop A → type-trunc-Prop (A + A) + ║ A ║₋₁ → ║ A + A ║₋₁ map-inv-trunc-Prop-diagonal-coproduct = map-universal-property-trunc-Prop ( trunc-Prop (A + A)) @@ -433,13 +454,13 @@ module _ map-trunc-Prop-diagonal-coproduct equiv-trunc-Prop-diagonal-coproduct : - type-trunc-Prop (A + A) ≃ type-trunc-Prop A + ║ A + A ║₋₁ ≃ ║ A ║₋₁ pr1 equiv-trunc-Prop-diagonal-coproduct = map-trunc-Prop-diagonal-coproduct pr2 equiv-trunc-Prop-diagonal-coproduct = is-equiv-map-trunc-Prop-diagonal-coproduct inv-equiv-trunc-Prop-diagonal-coproduct : - type-trunc-Prop A ≃ type-trunc-Prop (A + A) + ║ A ║₋₁ ≃ ║ A + A ║₋₁ pr1 inv-equiv-trunc-Prop-diagonal-coproduct = map-inv-trunc-Prop-diagonal-coproduct pr2 inv-equiv-trunc-Prop-diagonal-coproduct = diff --git a/src/foundation/split-surjective-maps.lagda.md b/src/foundation/split-surjective-maps.lagda.md index 10fb45cb17..be0a77d97c 100644 --- a/src/foundation/split-surjective-maps.lagda.md +++ b/src/foundation/split-surjective-maps.lagda.md @@ -95,25 +95,22 @@ module _ retraction-is-split-surjective-is-injective : is-injective f → is-split-surjective f → retraction f - pr1 (retraction-is-split-surjective-is-injective l s) = pr1 ∘ s - pr2 (retraction-is-split-surjective-is-injective l s) = l ∘ pr2 ∘ s ∘ f + retraction-is-split-surjective-is-injective l s = (pr1 ∘ s , l ∘ pr2 ∘ s ∘ f) is-equiv-is-split-surjective-is-injective : is-injective f → is-split-surjective f → is-equiv f - pr1 (is-equiv-is-split-surjective-is-injective l s) = - section-is-split-surjective f s - pr2 (is-equiv-is-split-surjective-is-injective l s) = - retraction-is-split-surjective-is-injective l s + is-equiv-is-split-surjective-is-injective l s = + ( section-is-split-surjective f s , + retraction-is-split-surjective-is-injective l s) is-split-surjective-is-equiv : is-equiv f → is-split-surjective f is-split-surjective-is-equiv = is-split-surjective-section f ∘ pr1 is-split-surjective-is-injective-is-equiv : is-equiv f → is-injective f × is-split-surjective f - pr1 (is-split-surjective-is-injective-is-equiv is-equiv-f) = - is-injective-is-equiv is-equiv-f - pr2 (is-split-surjective-is-injective-is-equiv is-equiv-f) = - is-split-surjective-is-equiv is-equiv-f + is-split-surjective-is-injective-is-equiv is-equiv-f = + ( is-injective-is-equiv is-equiv-f , + is-split-surjective-is-equiv is-equiv-f) ``` ## See also diff --git a/src/foundation/structure.lagda.md b/src/foundation/structure.lagda.md index 6a5b9217b7..4f5fa67f41 100644 --- a/src/foundation/structure.lagda.md +++ b/src/foundation/structure.lagda.md @@ -26,18 +26,31 @@ consists of a type `A` _equipped_ with an element of type `𝒫 A`. ## Definitions +### Structure at a universe + ```agda structure : {l1 l2 : Level} (𝒫 : UU l1 → UU l2) → UU (lsuc l1 ⊔ l2) structure {l1} 𝒫 = Σ (UU l1) 𝒫 -fam-structure : - {l1 l2 l3 : Level} (𝒫 : UU l1 → UU l2) (A : UU l3) → UU (lsuc l1 ⊔ l2 ⊔ l3) -fam-structure 𝒫 A = A → structure 𝒫 +structure-family : + {l1 l2 l3 : Level} (𝒫 : UU l1 → UU l2) {A : UU l3} → + (A → UU l1) → UU (l2 ⊔ l3) +structure-family 𝒫 {A} B = (x : A) → 𝒫 (B x) + +structured-family : + {l1 l2 l3 : Level} (𝒫 : UU l1 → UU l2) → UU l3 → UU (lsuc l1 ⊔ l2 ⊔ l3) +structured-family 𝒫 A = A → structure 𝒫 structure-map : {l1 l2 l3 : Level} (𝒫 : UU (l1 ⊔ l2) → UU l3) {A : UU l1} {B : UU l2} (f : A → B) → UU (l2 ⊔ l3) -structure-map 𝒫 {A} {B} f = (b : B) → 𝒫 (fiber f b) +structure-map 𝒫 {A} {B} f = structure-family 𝒫 (fiber f) + +structured-map : + {l1 l2 l3 : Level} + (𝒫 : UU (l1 ⊔ l2) → UU l3) + (A : UU l1) (B : UU l2) → UU (l1 ⊔ l2 ⊔ l3) +structured-map 𝒫 A B = Σ (A → B) (structure-map 𝒫) hom-structure : {l1 l2 l3 : Level} (𝒫 : UU (l1 ⊔ l2) → UU l3) → diff --git a/src/foundation/structured-type-duality.lagda.md b/src/foundation/structured-type-duality.lagda.md index e7d04bcb07..cdbbcfc227 100644 --- a/src/foundation/structured-type-duality.lagda.md +++ b/src/foundation/structured-type-duality.lagda.md @@ -36,7 +36,7 @@ Slice-structure l P B = Σ (UU l) (λ A → hom-structure P A B) equiv-Fiber-structure : {l1 l2 : Level} (l : Level) (P : UU (l1 ⊔ l) → UU l2) (B : UU l1) → - Slice-structure (l1 ⊔ l) P B ≃ fam-structure P B + Slice-structure (l1 ⊔ l) P B ≃ structured-family P B equiv-Fiber-structure {l1} {l3} l P B = ( ( inv-distributive-Π-Σ) ∘e ( equiv-Σ diff --git a/src/foundation/surjective-maps.lagda.md b/src/foundation/surjective-maps.lagda.md index f6fc1ffb05..3a233849c0 100644 --- a/src/foundation/surjective-maps.lagda.md +++ b/src/foundation/surjective-maps.lagda.md @@ -41,6 +41,7 @@ open import foundation-core.homotopies open import foundation-core.precomposition-dependent-functions open import foundation-core.propositional-maps open import foundation-core.propositions +open import foundation-core.retracts-of-types open import foundation-core.sections open import foundation-core.sets open import foundation-core.subtypes @@ -225,6 +226,16 @@ abstract is-surjective-has-section (g , G) b = unit-trunc-Prop (g b , G b) ``` +### The underlying surjection of a retract + +```agda +surjection-retract : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → + A retract-of B → B ↠ A +surjection-retract R = + ( map-retraction-retract R , is-surjective-has-section (section-retract R)) +``` + ### Any split surjective map is surjective ```agda diff --git a/src/foundation/uniformly-decidable-type-families.lagda.md b/src/foundation/uniformly-decidable-type-families.lagda.md index 01904ea182..caa6bc0aff 100644 --- a/src/foundation/uniformly-decidable-type-families.lagda.md +++ b/src/foundation/uniformly-decidable-type-families.lagda.md @@ -9,25 +9,28 @@ module foundation.uniformly-decidable-type-families where ```agda open import foundation.contractible-types open import foundation.coproduct-types +open import foundation.decidable-type-families open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.equality-coproduct-types +open import foundation.functoriality-coproduct-types open import foundation.inhabited-types +open import foundation.irrefutable-equality +open import foundation.mere-equality open import foundation.negation open import foundation.propositional-truncations open import foundation.propositions +open import foundation.subtypes +open import foundation.transport-along-identifications open import foundation.truncated-types open import foundation.truncation-levels open import foundation.type-arithmetic-empty-type open import foundation.universe-levels -open import foundation-core.cartesian-product-types -open import foundation-core.contractible-maps open import foundation-core.empty-types -open import foundation-core.equivalences open import foundation-core.function-types -open import foundation-core.homotopies -open import foundation-core.identity-types + +open import logic.propositionally-decidable-types ``` @@ -63,7 +66,7 @@ is-decidable-is-uniformly-decidable-family (inl f) x = inl (f x) is-decidable-is-uniformly-decidable-family (inr g) x = inr (g x) ``` -### The uniform decidability predicate on a family of truncated types +### The uniform decidability predicate on a family of contractible types ```agda module _ @@ -132,6 +135,16 @@ module _ rec-trunc-Prop ( is-prop-Prop (is-uniformly-decidable-family B)) ( is-prop-is-uniformly-decidable-family-is-inhabited-base' H) + +is-uniformly-decidable-family-Prop : + {l1 l2 : Level} + (A : Inhabited-Type l1) (B : subtype l2 (type-Inhabited-Type A)) → + Prop (l1 ⊔ l2) +is-uniformly-decidable-family-Prop (A , |a|) B = + ( is-uniformly-decidable-family (is-in-subtype B)) , + ( is-prop-is-uniformly-decidable-family-is-inhabited-base + ( is-prop-is-in-subtype B) + ( |a|)) ``` ### The uniform decidability predicate on a family of truncated types @@ -173,3 +186,76 @@ module _ ( succ-𝕋 (succ-𝕋 k)) H _ = is-trunc-succ-succ-is-uniformly-decidable-family k H ``` + +### Every family of decidable propositions over a decidable base with double negation dense equality is uniformly decidable + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} + (H : has-double-negation-dense-equality A) + (dB : is-decidable-family B) + where + + abstract + is-uniformly-decidable-family-has-double-negation-dense-equality-base : + is-decidable A → + is-uniformly-decidable-family B + is-uniformly-decidable-family-has-double-negation-dense-equality-base + (inl a) = + map-coproduct + ( λ b x → + double-negation-elim-is-decidable + ( dB x) + ( λ nb → H a x (λ p → nb (tr B p b)))) + ( λ nb x b → H x a (λ p → nb (tr B p b))) + ( dB a) + is-uniformly-decidable-family-has-double-negation-dense-equality-base + (inr na) = + inr (λ x _ → na x) + + abstract + is-uniformly-decidable-family-has-double-negation-dense-equality-base' : + is-inhabited-or-empty A → + ((x : A) → is-prop (B x)) → + is-uniformly-decidable-family B + is-uniformly-decidable-family-has-double-negation-dense-equality-base' + ( inl |a|) K = + rec-trunc-Prop + ( is-uniformly-decidable-family-Prop (A , |a|) (λ x → (B x , K x))) + ( is-uniformly-decidable-family-has-double-negation-dense-equality-base ∘ + inl) + ( |a|) + is-uniformly-decidable-family-has-double-negation-dense-equality-base' + ( inr na) K = + is-uniformly-decidable-family-has-double-negation-dense-equality-base + ( inr na) +``` + +### A family of decidable propositions over a decidable base with mere equality is uniformly decidable + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} + (H : all-elements-merely-equal A) + (dB : is-decidable-family B) + where + + abstract + is-uniformly-decidable-family-all-elements-merely-equal-base : + is-decidable A → + is-uniformly-decidable-family B + is-uniformly-decidable-family-all-elements-merely-equal-base = + is-uniformly-decidable-family-has-double-negation-dense-equality-base + ( has-double-negation-dense-equality-all-elements-merely-equal H) + ( dB) + + abstract + is-uniformly-decidable-family-all-elements-merely-equal-base' : + is-inhabited-or-empty A → + ((x : A) → is-prop (B x)) → + is-uniformly-decidable-family B + is-uniformly-decidable-family-all-elements-merely-equal-base' = + is-uniformly-decidable-family-has-double-negation-dense-equality-base' + ( has-double-negation-dense-equality-all-elements-merely-equal H) + ( dB) +``` diff --git a/src/foundation/universal-property-identity-types.lagda.md b/src/foundation/universal-property-identity-types.lagda.md index 1412af1bae..d9a24447ac 100644 --- a/src/foundation/universal-property-identity-types.lagda.md +++ b/src/foundation/universal-property-identity-types.lagda.md @@ -26,7 +26,6 @@ open import foundation-core.contractible-maps open import foundation-core.contractible-types open import foundation-core.families-of-equivalences open import foundation-core.fibers-of-maps -open import foundation-core.function-types open import foundation-core.functoriality-dependent-pair-types open import foundation-core.homotopies open import foundation-core.propositional-maps diff --git a/src/logic.lagda.md b/src/logic.lagda.md index 840556f77d..601198477e 100644 --- a/src/logic.lagda.md +++ b/src/logic.lagda.md @@ -14,11 +14,19 @@ open import logic.de-morgan-propositions public open import logic.de-morgan-subtypes public open import logic.de-morgan-types public open import logic.de-morgans-law public +open import logic.dirk-gentlys-principle public +open import logic.double-negation-dense-maps public +open import logic.double-negation-dense-subtypes public open import logic.double-negation-eliminating-maps public open import logic.double-negation-elimination public open import logic.double-negation-stable-embeddings public open import logic.double-negation-stable-subtypes public open import logic.functoriality-existential-quantification public +open import logic.irrefutable-types public open import logic.markovian-types public open import logic.markovs-principle public +open import logic.propositional-double-negation-elimination public +open import logic.propositionally-decidable-maps public +open import logic.propositionally-decidable-types public +open import logic.propositionally-double-negation-eliminating-maps public ``` diff --git a/src/logic/complements-decidable-subtypes.lagda.md b/src/logic/complements-decidable-subtypes.lagda.md index ae2a775f33..5887b51c6d 100644 --- a/src/logic/complements-decidable-subtypes.lagda.md +++ b/src/logic/complements-decidable-subtypes.lagda.md @@ -13,21 +13,19 @@ open import foundation.decidable-propositions open import foundation.decidable-subtypes open import foundation.decidable-types open import foundation.dependent-pair-types -open import foundation.double-negation-stable-propositions open import foundation.evaluation-functions open import foundation.full-subtypes open import foundation.involutions -open import foundation.negation -open import foundation.postcomposition-functions -open import foundation.powersets open import foundation.propositional-truncations +open import foundation.propositions +open import foundation.type-arithmetic-coproduct-types +open import foundation.type-arithmetic-dependent-pair-types open import foundation.unions-subtypes open import foundation.universe-levels +open import foundation-core.equivalences open import foundation-core.function-types open import foundation-core.subtypes - -open import logic.double-negation-stable-subtypes ``` @@ -44,9 +42,20 @@ the elements that are not in `B`. ### Complements of decidable subtypes ```agda -complement-decidable-subtype : - {l1 l2 : Level} {A : UU l1} → decidable-subtype l2 A → decidable-subtype l2 A -complement-decidable-subtype P x = neg-Decidable-Prop (P x) +module _ + {l1 l2 : Level} {A : UU l1} (P : decidable-subtype l2 A) + where + + complement-decidable-subtype : decidable-subtype l2 A + complement-decidable-subtype x = neg-Decidable-Prop (P x) + + type-complement-decidable-subtype : UU (l1 ⊔ l2) + type-complement-decidable-subtype = + type-decidable-subtype complement-decidable-subtype + + is-in-complement-decidable-subtype : A → UU l2 + is-in-complement-decidable-subtype = + is-in-decidable-subtype complement-decidable-subtype ``` ## Properties @@ -98,3 +107,31 @@ module _ ( subtype-decidable-subtype P) ( is-decidable-decidable-subtype P) ``` + +### The coproduct decomposition associated to a decidable subtype + +Every decidable subtype `P ⊆ A` decomposes `A` into a coproduct `A ≃ (P + A∖P)`. + +```agda +module _ + {l1 l2 : Level} {A : UU l1} (P : decidable-subtype l2 A) + where + + equiv-coproduct-decomposition-decidable-subtype : + A ≃ type-decidable-subtype P + type-complement-decidable-subtype P + equiv-coproduct-decomposition-decidable-subtype = + equivalence-reasoning + A + ≃ Σ A (λ x → is-decidable (is-in-decidable-subtype P x)) + by + inv-right-unit-law-Σ-is-contr + ( λ x → + is-proof-irrelevant-is-prop + ( is-prop-is-decidable (is-prop-is-in-decidable-subtype P x)) + ( is-decidable-decidable-subtype P x)) + ≃ type-decidable-subtype P + type-complement-decidable-subtype P + by + left-distributive-Σ-coproduct A + ( is-in-decidable-subtype P) + ( is-in-complement-decidable-subtype P) +``` diff --git a/src/logic/de-morgan-types.lagda.md b/src/logic/de-morgan-types.lagda.md index a87cd18593..37de751b7a 100644 --- a/src/logic/de-morgan-types.lagda.md +++ b/src/logic/de-morgan-types.lagda.md @@ -8,7 +8,6 @@ module logic.de-morgan-types where ```agda open import foundation.cartesian-product-types -open import foundation.conjunction open import foundation.contractible-types open import foundation.coproduct-types open import foundation.decidable-types @@ -16,13 +15,9 @@ open import foundation.dependent-pair-types open import foundation.disjunction open import foundation.double-negation open import foundation.empty-types -open import foundation.evaluation-functions open import foundation.function-types -open import foundation.identity-types -open import foundation.irrefutable-propositions open import foundation.logical-equivalences open import foundation.negation -open import foundation.precomposition-functions open import foundation.propositional-truncations open import foundation.retracts-of-types open import foundation.truncation-levels @@ -34,7 +29,8 @@ open import foundation-core.decidable-propositions open import foundation-core.equivalences open import foundation-core.propositions -open import logic.de-morgans-law +open import logic.irrefutable-types +open import logic.propositionally-decidable-types ``` @@ -249,7 +245,8 @@ module _ ### It is irrefutable that a type is De Morgan ```agda -is-irrefutable-is-de-morgan : {l : Level} {A : UU l} → ¬¬ (is-de-morgan A) +is-irrefutable-is-de-morgan : + {l : Level} {A : UU l} → is-irrefutable (is-de-morgan A) is-irrefutable-is-de-morgan = is-irrefutable-is-decidable ``` diff --git a/src/logic/dirk-gentlys-principle.lagda.md b/src/logic/dirk-gentlys-principle.lagda.md new file mode 100644 index 0000000000..3b8f8c0ef6 --- /dev/null +++ b/src/logic/dirk-gentlys-principle.lagda.md @@ -0,0 +1,68 @@ +# Dirk Gently's principle + +```agda +module logic.dirk-gentlys-principle where +``` + +
Imports + +```agda +open import foundation.disjunction +open import foundation.propositions +open import foundation.universe-levels +``` + +
+ +## Idea + +{{#concept "Dirk Gently's principle" Agda=Dirk-Gently's-Principle}} is the +logical axiom that the type of [propositions](foundation-core.propositions.md) +is [linearly ordered](order-theory.total-orders.md). In other words, for every +pair of propositions `P` and `Q`, either `P` implies `Q` or `Q` implies `P`: + +$$ + (P ⇒ Q) ∨ (Q ⇒ P). +$$ + +The proof strength of this principle lies strictly between the +[law of excluded middle](foundation.law-of-excluded-middle.md) and +[De Morgan's law](logic.de-morgans-law.md), Section 8.5 {{#cite Diener18}}. + +> The name is based on the guiding principle of the protagonist of Douglas +> Adam’s novel Dirk Gently’s Holistic Detective Agency who believes in the +> “fundamental interconnectedness of all things.” {{#cite Diener18}} + +## Statement + +```agda +instance-prop-Dirk-Gently's-Principle : + {l1 l2 : Level} → Prop l1 → Prop l2 → Prop (l1 ⊔ l2) +instance-prop-Dirk-Gently's-Principle P Q = (P ⇒ Q) ∨ (Q ⇒ P) + +instance-Dirk-Gently's-Principle : + {l1 l2 : Level} → Prop l1 → Prop l2 → UU (l1 ⊔ l2) +instance-Dirk-Gently's-Principle P Q = + type-Prop (instance-prop-Dirk-Gently's-Principle P Q) + +Dirk-Gently's-Principle-Level : (l1 l2 : Level) → UU (lsuc l1 ⊔ lsuc l2) +Dirk-Gently's-Principle-Level l1 l2 = + (P : Prop l1) (Q : Prop l2) → instance-Dirk-Gently's-Principle P Q + +Dirk-Gently's-Principle : UUω +Dirk-Gently's-Principle = + {l1 l2 : Level} → Dirk-Gently's-Principle-Level l1 l2 +``` + +## Properties + +### The law of excluded middle implies Dirk Gently's principle + +**Proof.** Assuming the law of excluded middle, then every proposition is either +true or false, so since false ≤ true, we are done. + +> This remains to be formalized. + +## References + +{{#bibliography}} diff --git a/src/logic/double-negation-dense-maps.lagda.md b/src/logic/double-negation-dense-maps.lagda.md new file mode 100644 index 0000000000..ab92b0b512 --- /dev/null +++ b/src/logic/double-negation-dense-maps.lagda.md @@ -0,0 +1,516 @@ +# Double negation dense maps + +```agda +module logic.double-negation-dense-maps where +``` + +
Imports + +```agda +open import foundation.connected-maps +open import foundation.dependent-pair-types +open import foundation.double-negation +open import foundation.functoriality-cartesian-product-types +open import foundation.functoriality-dependent-pair-types +open import foundation.fundamental-theorem-of-identity-types +open import foundation.homotopy-induction +open import foundation.identity-types +open import foundation.split-surjective-maps +open import foundation.structure-identity-principle +open import foundation.subtype-identity-principle +open import foundation.surjective-maps +open import foundation.univalence +open import foundation.universe-levels + +open import foundation-core.cartesian-product-types +open import foundation-core.contractible-maps +open import foundation-core.equivalences +open import foundation-core.fibers-of-maps +open import foundation-core.function-types +open import foundation-core.homotopies +open import foundation-core.propositions +open import foundation-core.retracts-of-types +open import foundation-core.sections +open import foundation-core.torsorial-type-families +open import foundation-core.truncation-levels + +open import logic.double-negation-stable-embeddings +open import logic.irrefutable-types +``` + +
+ +## Idea + +A map `f : A → B` is +{{#concept "double negation dense" Agda=is-double-negation-dense-map}}, if all +of its [fibers](foundation-core.fibers-of-maps.md) are +[irrefutable](foundation.irrefutable-propositions.md). I.e., for every `y : B`, +it is not not true that `y` has a preimage under `f`. + +Double negation dense maps are a close cousin of +[surjective maps](foundation.surjective-maps.md), but don't require the +existence of +[propositional truncations](foundation.propositional-truncations.md). In +particular, every map factors essentially uniquely as a double negation dense +map followed by a +[double negation stable embedding](logic.double-negation-stable-embeddings.md), +through its [double negation image](foundation.double-negation-images.md). + +## Definitions + +### The predicate on maps of being double negation dense + +```agda +is-double-negation-dense-map-Prop : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → (A → B) → Prop (l1 ⊔ l2) +is-double-negation-dense-map-Prop {B = B} f = + Π-Prop B (double-negation-type-Prop ∘ fiber f) + +is-double-negation-dense-map : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → (A → B) → UU (l1 ⊔ l2) +is-double-negation-dense-map f = type-Prop (is-double-negation-dense-map-Prop f) + +is-prop-is-double-negation-dense-map : + {l1 l2 : Level} {A : UU l1} {B : UU l2} (f : A → B) → + is-prop (is-double-negation-dense-map f) +is-prop-is-double-negation-dense-map f = + is-prop-type-Prop (is-double-negation-dense-map-Prop f) +``` + +### The type of double negation dense maps + +```agda +infix 5 _↠¬¬_ +_↠¬¬_ : {l1 l2 : Level} → UU l1 → UU l2 → UU (l1 ⊔ l2) +A ↠¬¬ B = Σ (A → B) is-double-negation-dense-map + +double-negation-dense-map : {l1 l2 : Level} → UU l1 → UU l2 → UU (l1 ⊔ l2) +double-negation-dense-map = _↠¬¬_ + +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} (f : A ↠¬¬ B) + where + + map-double-negation-dense-map : A → B + map-double-negation-dense-map = pr1 f + + is-double-negation-dense-map-double-negation-dense-map : + is-double-negation-dense-map map-double-negation-dense-map + is-double-negation-dense-map-double-negation-dense-map = pr2 f +``` + +### The type of all double negation dense maps out of a type + +```agda +Double-Negation-Dense-Map : + {l1 : Level} (l2 : Level) → UU l1 → UU (l1 ⊔ lsuc l2) +Double-Negation-Dense-Map l2 A = Σ (UU l2) (A ↠¬¬_) + +module _ + {l1 l2 : Level} {A : UU l1} (f : Double-Negation-Dense-Map l2 A) + where + + type-Double-Negation-Dense-Map : UU l2 + type-Double-Negation-Dense-Map = pr1 f + + double-negation-dense-map-Double-Negation-Dense-Map : + A ↠¬¬ type-Double-Negation-Dense-Map + double-negation-dense-map-Double-Negation-Dense-Map = pr2 f + + map-Double-Negation-Dense-Map : A → type-Double-Negation-Dense-Map + map-Double-Negation-Dense-Map = + map-double-negation-dense-map + double-negation-dense-map-Double-Negation-Dense-Map + + is-double-negation-dense-map-Double-Negation-Dense-Map : + is-double-negation-dense-map map-Double-Negation-Dense-Map + is-double-negation-dense-map-Double-Negation-Dense-Map = + is-double-negation-dense-map-double-negation-dense-map + double-negation-dense-map-Double-Negation-Dense-Map +``` + +## Properties + +### Any surjective map is double negation dense + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-double-negation-dense-map-is-surjective : + {f : A → B} → is-surjective f → is-double-negation-dense-map f + is-double-negation-dense-map-is-surjective H = + intro-double-negation-type-trunc-Prop ∘ H + + double-negation-dense-map-surjection : (A ↠ B) → (A ↠¬¬ B) + double-negation-dense-map-surjection = + tot (λ _ → is-double-negation-dense-map-is-surjective) +``` + +### Any map that has a section is double negation dense + +```agda +is-double-negation-dense-map-has-section : + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} → + section f → is-double-negation-dense-map f +is-double-negation-dense-map-has-section (g , G) b = + intro-double-negation (g b , G b) +``` + +### The underlying double negation dense map of a retract + +```agda +double-negation-dense-map-retract : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → + A retract-of B → B ↠¬¬ A +double-negation-dense-map-retract R = + ( map-retraction-retract R , + is-double-negation-dense-map-has-section (section-retract R)) +``` + +### Any split surjective map is double negation dense + +```agda +is-double-negation-dense-map-is-split-surjective : + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} → + is-split-surjective f → is-double-negation-dense-map f +is-double-negation-dense-map-is-split-surjective H = + intro-double-negation ∘ H +``` + +### Any equivalence is double negation dense + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-double-negation-dense-map-is-equiv : + {f : A → B} → is-equiv f → is-double-negation-dense-map f + is-double-negation-dense-map-is-equiv H = + is-double-negation-dense-map-has-section (section-is-equiv H) + + is-double-negation-dense-map-equiv : + (e : A ≃ B) → is-double-negation-dense-map (map-equiv e) + is-double-negation-dense-map-equiv e = + is-double-negation-dense-map-is-equiv (is-equiv-map-equiv e) + + double-negation-dense-map-equiv : A ≃ B → A ↠¬¬ B + double-negation-dense-map-equiv e = + (map-equiv e , is-double-negation-dense-map-equiv e) + + double-negation-dense-map-inv-equiv : B ≃ A → A ↠¬¬ B + double-negation-dense-map-inv-equiv e = + double-negation-dense-map-equiv (inv-equiv e) +``` + +### The identity function is double negation dense + +```agda +module _ + {l : Level} {A : UU l} + where + + is-double-negation-dense-map-id : is-double-negation-dense-map (id {A = A}) + is-double-negation-dense-map-id a = intro-double-negation (a , refl) +``` + +### A (k+1)-connected map is double negation dense + +```agda +is-double-negation-dense-map-is-connected-map : + {l1 l2 : Level} (k : 𝕋) {A : UU l1} {B : UU l2} + {f : A → B} → is-connected-map (succ-𝕋 k) f → + is-double-negation-dense-map f +is-double-negation-dense-map-is-connected-map k H = + is-double-negation-dense-map-is-surjective + ( is-surjective-is-connected-map k H) +``` + +### Maps which are homotopic to double negation dense maps are double negation dense + +```agda +module _ + { l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + abstract + is-double-negation-dense-map-htpy : + {f g : A → B} → f ~ g → + is-double-negation-dense-map g → is-double-negation-dense-map f + is-double-negation-dense-map-htpy {f} {g} H K b = + map-double-negation (map-equiv-fiber-htpy H b) (K b) + + abstract + is-double-negation-dense-map-htpy' : + {f g : A → B} → f ~ g → + is-double-negation-dense-map f → is-double-negation-dense-map g + is-double-negation-dense-map-htpy' H = + is-double-negation-dense-map-htpy (inv-htpy H) +``` + +### A map that is both double negation dense and a double negation stable embedding is an equivalence + +```agda +abstract + is-equiv-is-double-negation-stable-emb-is-double-negation-dense-map : + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} → + is-double-negation-dense-map f → + is-double-negation-stable-emb f → + is-equiv f + is-equiv-is-double-negation-stable-emb-is-double-negation-dense-map H K = + is-equiv-is-contr-map + ( λ y → + is-proof-irrelevant-is-prop + ( is-prop-map-is-double-negation-stable-emb K y) + ( is-double-negation-eliminating-map-is-double-negation-stable-emb K y + ( H y))) +``` + +### Composite of double negation dense maps + +```agda +module _ + {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {X : UU l3} + where + + is-double-negation-dense-map-comp : + {g : B → X} {h : A → B} → + is-double-negation-dense-map g → + is-double-negation-dense-map h → + is-double-negation-dense-map (g ∘ h) + is-double-negation-dense-map-comp {g} {h} G H x = + map-double-negation + ( map-inv-compute-fiber-comp g h x) + ( is-irrefutable-Σ (G x) (H ∘ pr1)) + + is-double-negation-dense-map-left-map-triangle : + (f : A → X) (g : B → X) (h : A → B) → f ~ g ∘ h → + is-double-negation-dense-map g → + is-double-negation-dense-map h → + is-double-negation-dense-map f + is-double-negation-dense-map-left-map-triangle f g h K G H = + is-double-negation-dense-map-htpy K (is-double-negation-dense-map-comp G H) + + comp-double-negation-dense-map : B ↠¬¬ X → A ↠¬¬ B → A ↠¬¬ X + comp-double-negation-dense-map (g , G) (h , H) = + ( g ∘ h , is-double-negation-dense-map-comp G H) +``` + +### Products of double negation dense maps + +```agda +module _ + {l1 l2 l3 l4 : Level} {A : UU l1} {B : UU l2} {C : UU l3} {D : UU l4} + where + + is-double-negation-dense-map-product : + {f : A → C} {g : B → D} → + is-double-negation-dense-map f → + is-double-negation-dense-map g → + is-double-negation-dense-map (map-product f g) + is-double-negation-dense-map-product {f} {g} F G (c , d) = + map-double-negation + ( map-inv-compute-fiber-map-product f g (c , d)) + ( is-irrefutable-product (F c) (G d)) + + double-negation-dense-map-product : + (A ↠¬¬ C) → (B ↠¬¬ D) → ((A × B) ↠¬¬ (C × D)) + double-negation-dense-map-product f g = + map-product + ( map-double-negation-dense-map f) + ( map-double-negation-dense-map g) , + is-double-negation-dense-map-product + ( is-double-negation-dense-map-double-negation-dense-map f) + ( is-double-negation-dense-map-double-negation-dense-map g) +``` + +### The composite of a double negation dense map before an equivalence is double negation dense + +```agda +is-double-negation-dense-map-left-comp-equiv : + {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {C : UU l3} + (e : B ≃ C) {f : A → B} → + is-double-negation-dense-map f → + is-double-negation-dense-map (map-equiv e ∘ f) +is-double-negation-dense-map-left-comp-equiv e = + is-double-negation-dense-map-comp (is-double-negation-dense-map-equiv e) +``` + +### The composite of a double negation dense map after an equivalence is double negation dense + +```agda +is-double-negation-dense-map-right-comp-equiv : + {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {C : UU l3} {f : B → C} → + is-double-negation-dense-map f → + (e : A ≃ B) → + is-double-negation-dense-map (f ∘ map-equiv e) +is-double-negation-dense-map-right-comp-equiv H e = + is-double-negation-dense-map-comp H (is-double-negation-dense-map-equiv e) +``` + +### If a composite is double negation dense, then so is its left factor + +```agda +module _ + {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {X : UU l3} + where + + is-double-negation-dense-map-left-factor : + {g : B → X} (h : A → B) → + is-double-negation-dense-map (g ∘ h) → is-double-negation-dense-map g + is-double-negation-dense-map-left-factor {g} h GH x = + map-double-negation (pr1 ∘ map-compute-fiber-comp g h x) (GH x) + + is-double-negation-dense-map-right-map-triangle' : + (f : A → X) (g : B → X) (h : A → B) → g ∘ h ~ f → + is-double-negation-dense-map f → is-double-negation-dense-map g + is-double-negation-dense-map-right-map-triangle' f g h K F = + is-double-negation-dense-map-left-factor h + ( is-double-negation-dense-map-htpy K F) + + is-double-negation-dense-map-right-map-triangle : + (f : A → X) (g : B → X) (h : A → B) → f ~ g ∘ h → + is-double-negation-dense-map f → is-double-negation-dense-map g + is-double-negation-dense-map-right-map-triangle f g h K = + is-double-negation-dense-map-right-map-triangle' f g h (inv-htpy K) +``` + +### Characterization of the identity type of `A ↠¬¬ B` + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} (f : A ↠¬¬ B) + where + + htpy-double-negation-dense-map : (A ↠¬¬ B) → UU (l1 ⊔ l2) + htpy-double-negation-dense-map g = + map-double-negation-dense-map f ~ map-double-negation-dense-map g + + refl-htpy-double-negation-dense-map : htpy-double-negation-dense-map f + refl-htpy-double-negation-dense-map = refl-htpy + + is-torsorial-htpy-double-negation-dense-map : + is-torsorial htpy-double-negation-dense-map + is-torsorial-htpy-double-negation-dense-map = + is-torsorial-Eq-subtype + ( is-torsorial-htpy (map-double-negation-dense-map f)) + ( is-prop-is-double-negation-dense-map) + ( map-double-negation-dense-map f) + ( refl-htpy) + ( is-double-negation-dense-map-double-negation-dense-map f) + + htpy-eq-double-negation-dense-map : + (g : A ↠¬¬ B) → (f ＝ g) → htpy-double-negation-dense-map g + htpy-eq-double-negation-dense-map .f refl = + refl-htpy-double-negation-dense-map + + is-equiv-htpy-eq-double-negation-dense-map : + (g : A ↠¬¬ B) → is-equiv (htpy-eq-double-negation-dense-map g) + is-equiv-htpy-eq-double-negation-dense-map = + fundamental-theorem-id + is-torsorial-htpy-double-negation-dense-map + htpy-eq-double-negation-dense-map + + extensionality-double-negation-dense-map : + (g : A ↠¬¬ B) → (f ＝ g) ≃ htpy-double-negation-dense-map g + extensionality-double-negation-dense-map g = + ( htpy-eq-double-negation-dense-map g , + is-equiv-htpy-eq-double-negation-dense-map g) + + eq-htpy-double-negation-dense-map : + (g : A ↠¬¬ B) → htpy-double-negation-dense-map g → f ＝ g + eq-htpy-double-negation-dense-map g = + map-inv-equiv (extensionality-double-negation-dense-map g) +``` + +### Characterization of the identity type of `Double-Negation-Dense-Map l2 A` + +```agda +equiv-Double-Negation-Dense-Map : + {l1 l2 l3 : Level} {A : UU l1} → + Double-Negation-Dense-Map l2 A → + Double-Negation-Dense-Map l3 A → + UU (l1 ⊔ l2 ⊔ l3) +equiv-Double-Negation-Dense-Map f g = + Σ ( type-Double-Negation-Dense-Map f ≃ + type-Double-Negation-Dense-Map g) + ( λ e → + map-equiv e ∘ map-Double-Negation-Dense-Map f ~ + map-Double-Negation-Dense-Map g) + +module _ + {l1 l2 : Level} {A : UU l1} (f : Double-Negation-Dense-Map l2 A) + where + + id-equiv-Double-Negation-Dense-Map : equiv-Double-Negation-Dense-Map f f + pr1 id-equiv-Double-Negation-Dense-Map = id-equiv + pr2 id-equiv-Double-Negation-Dense-Map = refl-htpy + + is-torsorial-equiv-Double-Negation-Dense-Map : + is-torsorial (equiv-Double-Negation-Dense-Map f) + is-torsorial-equiv-Double-Negation-Dense-Map = + is-torsorial-Eq-structure + ( is-torsorial-equiv (type-Double-Negation-Dense-Map f)) + ( type-Double-Negation-Dense-Map f , id-equiv) + ( is-torsorial-htpy-double-negation-dense-map + ( double-negation-dense-map-Double-Negation-Dense-Map f)) + + equiv-eq-Double-Negation-Dense-Map : + (g : Double-Negation-Dense-Map l2 A) → + f ＝ g → equiv-Double-Negation-Dense-Map f g + equiv-eq-Double-Negation-Dense-Map .f refl = + id-equiv-Double-Negation-Dense-Map + + is-equiv-equiv-eq-Double-Negation-Dense-Map : + (g : Double-Negation-Dense-Map l2 A) → + is-equiv (equiv-eq-Double-Negation-Dense-Map g) + is-equiv-equiv-eq-Double-Negation-Dense-Map = + fundamental-theorem-id + is-torsorial-equiv-Double-Negation-Dense-Map + equiv-eq-Double-Negation-Dense-Map + + extensionality-Double-Negation-Dense-Map : + (g : Double-Negation-Dense-Map l2 A) → + (f ＝ g) ≃ equiv-Double-Negation-Dense-Map f g + pr1 (extensionality-Double-Negation-Dense-Map g) = + equiv-eq-Double-Negation-Dense-Map g + pr2 (extensionality-Double-Negation-Dense-Map g) = + is-equiv-equiv-eq-Double-Negation-Dense-Map g + + eq-equiv-Double-Negation-Dense-Map : + (g : Double-Negation-Dense-Map l2 A) → + equiv-Double-Negation-Dense-Map f g → f ＝ g + eq-equiv-Double-Negation-Dense-Map g = + map-inv-equiv (extensionality-Double-Negation-Dense-Map g) +``` + +### Every type that maps double negation densely onto an irrefutable type is irrefutable + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-irrefutable-is-double-negation-dense-map : + {f : A → B} → is-double-negation-dense-map f → ¬¬ B → ¬¬ A + is-irrefutable-is-double-negation-dense-map F nnb na = + nnb (λ b → F b (λ p → na (pr1 p))) + + is-irrefutable-double-negation-dense-map : + A ↠¬¬ B → ¬¬ B → ¬¬ A + is-irrefutable-double-negation-dense-map f = + is-irrefutable-is-double-negation-dense-map + ( is-double-negation-dense-map-double-negation-dense-map f) +``` + +## See also + +- [Double negation modality](foundation.double-negation-modality.md) + +## External links + +- [TypeTopology.Density](https://martinescardo.github.io/TypeTopology/TypeTopology.Density.html) + at TypeTopology diff --git a/src/logic/double-negation-dense-subtypes.lagda.md b/src/logic/double-negation-dense-subtypes.lagda.md new file mode 100644 index 0000000000..0afa4b0cb6 --- /dev/null +++ b/src/logic/double-negation-dense-subtypes.lagda.md @@ -0,0 +1,143 @@ +# Double negation dense subtypes of types + +```agda +module logic.double-negation-dense-subtypes where +``` + +
Imports + +```agda +open import foundation.complements-subtypes +open import foundation.dependent-pair-types +open import foundation.double-negation +open import foundation.full-subtypes +open import foundation.function-types +open import foundation.type-arithmetic-dependent-pair-types +open import foundation.unit-type +open import foundation.universe-levels + +open import foundation-core.equivalences +open import foundation-core.identity-types +open import foundation-core.propositions +open import foundation-core.subtypes +open import foundation-core.transport-along-identifications + +open import logic.double-negation-dense-maps +``` + +
+ +## Idea + +A +{{#concept "double negationdense" Disambiguation="subtype" Agda=is-double-negation-dense-subtype Agda=double-negation-dense-subtype}} +[subtype](foundation.subtypes.md) of a type `X` is a subtype `P ⊆ X` such that +its double [complement](foundation.complements-subtypes.md) is +[full](foundation.full-subtypes.md). + +## Definitions + +### The predicate on a subtype of being double negation dense + +```agda +module _ + {l1 l2 : Level} {A : UU l1} (P : subtype l2 A) + where + + is-double-negation-dense-subtype-Prop : Prop (l1 ⊔ l2) + is-double-negation-dense-subtype-Prop = + is-full-subtype-Prop (complement-subtype (complement-subtype P)) + + is-double-negation-dense-subtype : UU (l1 ⊔ l2) + is-double-negation-dense-subtype = + type-Prop is-double-negation-dense-subtype-Prop + + is-prop-is-double-negation-dense-subtype : + is-prop is-double-negation-dense-subtype + is-prop-is-double-negation-dense-subtype = + is-prop-type-Prop is-double-negation-dense-subtype-Prop +``` + +### The type of double negation dense subtypes + +```agda +double-negation-dense-subtype : + {l1 : Level} (l2 : Level) → UU l1 → UU (l1 ⊔ lsuc l2) +double-negation-dense-subtype l2 A = + Σ (subtype l2 A) is-double-negation-dense-subtype + +module _ + {l1 l2 : Level} {A : UU l1} (P : double-negation-dense-subtype l2 A) + where + + subtype-double-negation-dense-subtype : subtype l2 A + subtype-double-negation-dense-subtype = pr1 P + + is-double-negation-dense-double-negation-dense-subtype : + is-double-negation-dense-subtype subtype-double-negation-dense-subtype + is-double-negation-dense-double-negation-dense-subtype = pr2 P + + type-double-negation-dense-subtype : UU (l1 ⊔ l2) + type-double-negation-dense-subtype = + type-subtype subtype-double-negation-dense-subtype + + is-in-double-negation-dense-subtype : A → UU l2 + is-in-double-negation-dense-subtype = + is-in-subtype subtype-double-negation-dense-subtype + + is-prop-is-in-double-negation-dense-subtype : + (x : A) → is-prop (is-in-double-negation-dense-subtype x) + is-prop-is-in-double-negation-dense-subtype = + is-prop-is-in-subtype subtype-double-negation-dense-subtype + + inclusion-double-negation-dense-subtype : + type-double-negation-dense-subtype → A + inclusion-double-negation-dense-subtype = + inclusion-subtype subtype-double-negation-dense-subtype +``` + +## Properties + +### A subtype is double negation dense if and only if the inclusion is double negation dense + +```agda +module _ + {l1 l2 : Level} {A : UU l1} (P : subtype l2 A) + where + + is-double-negation-dense-inclusion-is-double-negation-dense-subtype : + is-double-negation-dense-subtype P → + is-double-negation-dense-map (inclusion-subtype P) + is-double-negation-dense-inclusion-is-double-negation-dense-subtype H x = + map-double-negation (λ y → ((x , y) , refl)) (H x) + + double-negation-dense-inclusion-is-double-negation-dense-subtype : + is-double-negation-dense-subtype P → type-subtype P ↠¬¬ A + double-negation-dense-inclusion-is-double-negation-dense-subtype H = + ( inclusion-subtype P , + is-double-negation-dense-inclusion-is-double-negation-dense-subtype H) + + is-dense-is-double-negation-dense-inclusion-subtype : + is-double-negation-dense-map (inclusion-subtype P) → + is-double-negation-dense-subtype P + is-dense-is-double-negation-dense-inclusion-subtype H x = + map-double-negation (λ p → tr (is-in-subtype P) (pr2 p) (pr2 (pr1 p))) (H x) + +module _ + {l1 l2 : Level} {A : UU l1} (P : double-negation-dense-subtype l2 A) + where + + is-double-negation-dense-inclusion-double-negation-dense-subtype : + is-double-negation-dense-map (inclusion-double-negation-dense-subtype P) + is-double-negation-dense-inclusion-double-negation-dense-subtype = + is-double-negation-dense-inclusion-is-double-negation-dense-subtype + ( subtype-double-negation-dense-subtype P) + ( is-double-negation-dense-double-negation-dense-subtype P) + + double-negation-dense-inclusion-double-negation-dense-subtype : + type-double-negation-dense-subtype P ↠¬¬ A + double-negation-dense-inclusion-double-negation-dense-subtype = + double-negation-dense-inclusion-is-double-negation-dense-subtype + ( subtype-double-negation-dense-subtype P) + ( is-double-negation-dense-double-negation-dense-subtype P) +``` diff --git a/src/logic/double-negation-eliminating-maps.lagda.md b/src/logic/double-negation-eliminating-maps.lagda.md index 836e3191e1..8313f7656b 100644 --- a/src/logic/double-negation-eliminating-maps.lagda.md +++ b/src/logic/double-negation-eliminating-maps.lagda.md @@ -10,7 +10,6 @@ module logic.double-negation-eliminating-maps where open import foundation.action-on-identifications-functions open import foundation.cartesian-morphisms-arrows open import foundation.coproduct-types -open import foundation.decidable-equality open import foundation.decidable-maps open import foundation.decidable-types open import foundation.dependent-pair-types @@ -18,11 +17,10 @@ open import foundation.double-negation open import foundation.empty-types open import foundation.functoriality-cartesian-product-types open import foundation.functoriality-coproduct-types +open import foundation.hilbert-epsilon-operators-maps open import foundation.identity-types open import foundation.injective-maps -open import foundation.retractions open import foundation.retracts-of-maps -open import foundation.retracts-of-types open import foundation.transport-along-identifications open import foundation.universe-levels @@ -180,7 +178,7 @@ module _ (y : B) → ¬¬ (fiber f y) → Σ (fiber g (g y)) (λ t → fiber f (pr1 t)) fiber-comp-is-double-negation-eliminating-map-right-factor' y nnfy = map-compute-fiber-comp g f (g y) - ( GF (g y) (λ ngfgy → nnfy λ x → ngfgy ((pr1 x) , ap g (pr2 x)))) + ( GF (g y) (map-double-negation (λ x → (pr1 x , ap g (pr2 x))) nnfy)) is-double-negation-eliminating-map-right-factor' : is-injective g → is-double-negation-eliminating-map f @@ -333,3 +331,27 @@ module _ ( retract-fiber-retract-map f g R x) ( G (map-codomain-inclusion-retract-map f g R x)) ``` + +### Double negation eliminating maps have Hilbert ε-operators + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + ε-operator-map-is-double-negation-eliminating-map : + {f : A → B} → is-double-negation-eliminating-map f → ε-operator-map f + ε-operator-map-is-double-negation-eliminating-map H x = + ε-operator-Hilbert-has-double-negation-elim (H x) + + ε-operator-double-negation-eliminating-map : + (f : A →¬¬ B) → ε-operator-map (map-double-negation-eliminating-map f) + ε-operator-double-negation-eliminating-map f = + ε-operator-map-is-double-negation-eliminating-map + ( is-double-negation-eliminating-double-negation-eliminating-map f) +``` + +## See also + +- In [double negation images](foundation.double-negation-images.md) we show that + injective maps with double negation elimination are embeddings. diff --git a/src/logic/double-negation-elimination.lagda.md b/src/logic/double-negation-elimination.lagda.md index 1acfd21ebb..da4cab7023 100644 --- a/src/logic/double-negation-elimination.lagda.md +++ b/src/logic/double-negation-elimination.lagda.md @@ -12,20 +12,21 @@ open import foundation.coproduct-types open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.double-negation +open import foundation.empty-types open import foundation.evaluation-functions open import foundation.hilberts-epsilon-operators +open import foundation.irrefutable-equality open import foundation.logical-equivalences +open import foundation.mere-equality +open import foundation.negation open import foundation.retracts-of-types open import foundation.transport-along-identifications open import foundation.unit-type open import foundation.universe-levels open import foundation-core.contractible-types -open import foundation-core.decidable-propositions -open import foundation-core.empty-types open import foundation-core.equivalences open import foundation-core.function-types -open import foundation-core.negation open import foundation-core.propositions ``` @@ -171,6 +172,81 @@ double-negation-elim-neg : double-negation-elim-neg A f p = f (ev p) ``` +### Double negation elimination for dependent sums of types with double negation elimination over a double negation stable proposition + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} + where + + double-negation-elim-Σ-has-double-negation-dense-equality-base : + has-double-negation-dense-equality A → + has-double-negation-elim A → + ((x : A) → has-double-negation-elim (B x)) → + has-double-negation-elim (Σ A B) + double-negation-elim-Σ-has-double-negation-dense-equality-base H f g h = + ( f ( map-double-negation pr1 h)) , + ( g ( f ( map-double-negation pr1 h)) + ( λ nb → + h ( λ x → + H ( pr1 x) + ( f (map-double-negation pr1 h)) + ( λ p → nb (tr B p (pr2 x)))))) + + double-negation-elim-Σ-all-elements-merely-equal-base : + all-elements-merely-equal A → + has-double-negation-elim A → + ((x : A) → has-double-negation-elim (B x)) → + has-double-negation-elim (Σ A B) + double-negation-elim-Σ-all-elements-merely-equal-base H = + double-negation-elim-Σ-has-double-negation-dense-equality-base + ( has-double-negation-dense-equality-all-elements-merely-equal H) + + double-negation-elim-Σ-is-prop-base : + is-prop A → has-double-negation-elim A → + ((x : A) → has-double-negation-elim (B x)) → + has-double-negation-elim (Σ A B) + double-negation-elim-Σ-is-prop-base is-prop-A = + double-negation-elim-Σ-has-double-negation-dense-equality-base + ( λ x y → intro-double-negation (eq-is-prop is-prop-A)) + + double-negation-elim-base-Σ-section' : + has-double-negation-elim (Σ A B) → + (A → Σ A B) → + has-double-negation-elim A + double-negation-elim-base-Σ-section' H f nna = + pr1 (H (map-double-negation f nna)) + + double-negation-elim-base-Σ-section : + has-double-negation-elim (Σ A B) → + ((x : A) → B x) → + has-double-negation-elim A + double-negation-elim-base-Σ-section H f = + double-negation-elim-base-Σ-section' H (λ x → x , f x) + + double-negation-elim-family-Σ-is-prop-base : + has-double-negation-elim (Σ A B) → + is-prop A → + (x : A) → has-double-negation-elim (B x) + double-negation-elim-family-Σ-is-prop-base K is-prop-A x nnb = + tr B (eq-is-prop is-prop-A) (pr2 (K (map-double-negation (pair x) nnb))) +``` + +### Double negation elimination for products of types with double negation elimination + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + double-negation-elim-product : + has-double-negation-elim A → + has-double-negation-elim B → + has-double-negation-elim (A × B) + double-negation-elim-product f g h = + ( f (map-double-negation pr1 h) , g (map-double-negation pr2 h)) +``` + ### Double negation elimination for universal quantification over double negations ```agda @@ -178,17 +254,15 @@ module _ {l1 l2 : Level} {P : UU l1} {Q : P → UU l2} where - double-negation-elim-for-all-neg-neg : + double-negation-elim-Π-neg-neg : has-double-negation-elim ((p : P) → ¬¬ (Q p)) - double-negation-elim-for-all-neg-neg f p = - double-negation-elim-neg - ( ¬ (Q p)) - ( map-double-negation (λ (g : (u : P) → ¬¬ (Q u)) → g p) f) + double-negation-elim-Π-neg-neg f p = + double-negation-elim-neg (¬ (Q p)) (map-double-negation (ev p) f) - double-negation-elim-for-all : + double-negation-elim-Π : ((p : P) → has-double-negation-elim (Q p)) → has-double-negation-elim ((p : P) → Q p) - double-negation-elim-for-all H f p = H p (λ nq → f (λ g → nq (g p))) + double-negation-elim-Π H f p = H p (map-double-negation (ev p) f) ``` ### Double negation elimination for function types into double negations @@ -198,61 +272,21 @@ module _ {l1 l2 : Level} {P : UU l1} {Q : UU l2} where - double-negation-elim-exp-neg-neg : - has-double-negation-elim (P → ¬¬ Q) - double-negation-elim-exp-neg-neg = - double-negation-elim-for-all-neg-neg + double-negation-elim-exp-neg-neg : has-double-negation-elim (P → ¬¬ Q) + double-negation-elim-exp-neg-neg = double-negation-elim-Π-neg-neg double-negation-elim-exp : - has-double-negation-elim Q → - has-double-negation-elim (P → Q) - double-negation-elim-exp q = double-negation-elim-for-all (λ _ → q) -``` - -### Double negation elimination for dependent sums of types with double negation elimination over a double negation stable proposition - -```agda -double-negation-elim-Σ-is-prop-base : - {l1 l2 : Level} {A : UU l1} {B : A → UU l2} → - is-prop A → - has-double-negation-elim A → - ((a : A) → has-double-negation-elim (B a)) → - has-double-negation-elim (Σ A B) -double-negation-elim-Σ-is-prop-base {B = B} is-prop-A f g h = - ( f (λ na → h (na ∘ pr1))) , - ( g ( f (λ na → h (na ∘ pr1))) - ( λ nb → h (λ y → nb (tr B (eq-is-prop is-prop-A) (pr2 y))))) - -double-negation-elim-Σ-is-decidable-prop-base : - {l1 l2 : Level} {P : UU l1} {B : P → UU l2} → - is-decidable-prop P → - ((x : P) → has-double-negation-elim (B x)) → - has-double-negation-elim (Σ P B) -double-negation-elim-Σ-is-decidable-prop-base (H , d) = - double-negation-elim-Σ-is-prop-base H (double-negation-elim-is-decidable d) -``` - -### Double negation elimination for products of types with double negation elimination - -```agda -double-negation-elim-product : - {l1 l2 : Level} {A : UU l1} {B : UU l2} → - has-double-negation-elim A → - has-double-negation-elim B → - has-double-negation-elim (A × B) -double-negation-elim-product f g h = - f (λ na → h (na ∘ pr1)) , g (λ nb → h (nb ∘ pr2)) + has-double-negation-elim Q → has-double-negation-elim (P → Q) + double-negation-elim-exp q = double-negation-elim-Π (λ _ → q) ``` ### If a type satisfies untruncated double negation elimination then it has a Hilbert ε-operator ```agda ε-operator-Hilbert-has-double-negation-elim : - {l1 : Level} {A : UU l1} → - has-double-negation-elim A → - ε-operator-Hilbert A -ε-operator-Hilbert-has-double-negation-elim {A = A} H = - H ∘ double-negation-double-negation-type-trunc-Prop A ∘ intro-double-negation + {l1 : Level} {A : UU l1} → has-double-negation-elim A → ε-operator-Hilbert A +ε-operator-Hilbert-has-double-negation-elim H = + H ∘ double-negation-double-negation-type-trunc-Prop ∘ intro-double-negation ``` ## See also diff --git a/src/logic/double-negation-stable-embeddings.lagda.md b/src/logic/double-negation-stable-embeddings.lagda.md index 4e6a207085..ccca6ddc30 100644 --- a/src/logic/double-negation-stable-embeddings.lagda.md +++ b/src/logic/double-negation-stable-embeddings.lagda.md @@ -10,9 +10,6 @@ module logic.double-negation-stable-embeddings where open import foundation.action-on-identifications-functions open import foundation.cartesian-morphisms-arrows open import foundation.decidable-embeddings -open import foundation.decidable-maps -open import foundation.decidable-propositions -open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.double-negation-stable-propositions open import foundation.embeddings @@ -23,18 +20,15 @@ open import foundation.fundamental-theorem-of-identity-types open import foundation.homotopy-induction open import foundation.identity-types open import foundation.logical-equivalences -open import foundation.negation open import foundation.propositional-maps open import foundation.propositions open import foundation.retracts-of-maps open import foundation.subtype-identity-principle -open import foundation.type-arithmetic-dependent-pair-types open import foundation.unit-type open import foundation.universal-property-equivalences open import foundation.universe-levels open import foundation-core.cartesian-product-types -open import foundation-core.coproduct-types open import foundation-core.empty-types open import foundation-core.equivalences open import foundation-core.function-types @@ -62,6 +56,12 @@ Equivalently, a double negation stable embedding is a map whose fibers are We refer to this condition as being a {{#concept "double negation stable propositional map" Disambiguation="of types" Agda=is-double-negation-stable-prop-map}}. +Double negation stable embeddings form the right class of an orthogonal +factorization system on types whose left class is +[double negation dense maps](logic.double-negation-dense-maps.md). This +orthogonal factorization system is determined by the +[double negation modality](foundation.double-negation-modality.md). + ## Definitions ### The condition on a map of being a double negation stable embedding @@ -729,3 +729,7 @@ module _ ( is-emb-terminal-map-is-prop (is-prop-type-Prop P))) ( p)) ``` + +## See also + +- [Double negation images](foundation.double-negation-images.md) diff --git a/src/logic/irrefutable-types.lagda.md b/src/logic/irrefutable-types.lagda.md new file mode 100644 index 0000000000..f26c0613de --- /dev/null +++ b/src/logic/irrefutable-types.lagda.md @@ -0,0 +1,167 @@ +# Irrefutable types + +```agda +module logic.irrefutable-types where +``` + +
Imports + +```agda +open import foundation.cartesian-product-types +open import foundation.contractible-types +open import foundation.coproduct-types +open import foundation.decidable-types +open import foundation.dependent-pair-types +open import foundation.double-negation +open import foundation.empty-types +open import foundation.function-types +open import foundation.inhabited-types +open import foundation.negation +open import foundation.propositions +open import foundation.subuniverses +open import foundation.unit-type +open import foundation.universe-levels + +open import logic.double-negation-elimination +``` + +
+ +## Idea + +The [subuniverse](foundation.subuniverses.md) of +{{#concept "irrefutable types" Agda=Irrefutable-Type}}, or **double negation +dense types**, consists of types `X` for which the +[double negation](foundation.double-negation.md) `¬¬X` is true. + +## Definitions + +### The predicate on a type of being irrefutable + +```agda +is-irrefutable : {l : Level} → UU l → UU l +is-irrefutable X = ¬¬ X + +is-prop-is-irrefutable : {l : Level} {X : UU l} → is-prop (is-irrefutable X) +is-prop-is-irrefutable = is-prop-double-negation + +is-irrefutable-prop-Type : {l : Level} → UU l → Prop l +is-irrefutable-prop-Type X = (is-irrefutable X , is-prop-is-irrefutable) +``` + +### The subuniverse of irrefutable types + +```agda +Irrefutable-Type : (l : Level) → UU (lsuc l) +Irrefutable-Type l = type-subuniverse is-irrefutable-prop-Type + +make-Irrefutable-Type : + {l : Level} {X : UU l} → is-irrefutable X → Irrefutable-Type l +make-Irrefutable-Type {X = X} is-irrefutable-X = (X , is-irrefutable-X) + +module _ + {l : Level} (X : Irrefutable-Type l) + where + + type-Irrefutable-Type : UU l + type-Irrefutable-Type = pr1 X + + is-irrefutable-Irrefutable-Type : is-irrefutable type-Irrefutable-Type + is-irrefutable-Irrefutable-Type = pr2 X +``` + +## Properties + +### Provable types are irrefutable + +```agda +is-irrefutable-has-element : {l : Level} {X : UU l} → X → is-irrefutable X +is-irrefutable-has-element = intro-double-negation + +is-irrefutable-unit : is-irrefutable unit +is-irrefutable-unit = is-irrefutable-has-element star +``` + +### Inhabited types are irrefutable + +```agda +is-irrefutable-is-inhabited : + {l : Level} {X : UU l} → is-inhabited X → is-irrefutable X +is-irrefutable-is-inhabited = intro-double-negation-type-trunc-Prop +``` + +### Contractible types are irrefutable + +```agda +is-irrefutable-is-contr : + {l : Level} {X : UU l} → is-contr X → is-irrefutable X +is-irrefutable-is-contr H = intro-double-negation (center H) +``` + +### If it is irrefutable that a type is irrefutable, then the type is irrefutable + +```agda +is-idempotent-is-irrefutable : + {l : Level} {X : UU l} → is-irrefutable (is-irrefutable X) → is-irrefutable X +is-idempotent-is-irrefutable {X = X} = double-negation-elim-neg (¬ X) +``` + +### Decidability is irrefutable + +```agda +is-irrefutable-is-decidable : + {l : Level} {A : UU l} → is-irrefutable (is-decidable A) +is-irrefutable-is-decidable H = H (inr (H ∘ inl)) +``` + +### Double negation elimination is irrefutable + +```agda +is-irrefutable-double-negation-elim : + {l : Level} {A : UU l} → is-irrefutable (has-double-negation-elim A) +is-irrefutable-double-negation-elim H = + H (λ f → ex-falso (f (λ a → H (λ _ → a)))) +``` + +### Dependent sums of irrefutable types + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} + where + + is-irrefutable-Σ : + is-irrefutable A → ((x : A) → is-irrefutable (B x)) → is-irrefutable (Σ A B) + is-irrefutable-Σ nna nnb nab = nna (λ a → nnb a (λ b → nab (a , b))) +``` + +### Products of irrefutable types + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-irrefutable-product : + is-irrefutable A → is-irrefutable B → is-irrefutable (A × B) + is-irrefutable-product nna nnb = is-irrefutable-Σ nna (λ _ → nnb) +``` + +### Coproducts of irrefutable types + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-irrefutable-coproduct-inl : is-irrefutable A → is-irrefutable (A + B) + is-irrefutable-coproduct-inl nna x = nna (x ∘ inl) + + is-irrefutable-coproduct-inr : is-irrefutable B → is-irrefutable (A + B) + is-irrefutable-coproduct-inr nnb x = nnb (x ∘ inr) +``` + +## See also + +- [Irrefutable propositions](foundation.irrefutable-propositions.md) +- [De Morgan's law](logic.de-morgans-law.md) is irrefutable diff --git a/src/logic/markovian-types.lagda.md b/src/logic/markovian-types.lagda.md index 54b779cddd..8e9fd0e12e 100644 --- a/src/logic/markovian-types.lagda.md +++ b/src/logic/markovian-types.lagda.md @@ -7,24 +7,15 @@ module logic.markovian-types where
Imports ```agda -open import elementary-number-theory.natural-numbers - open import foundation.booleans open import foundation.decidable-subtypes -open import foundation.dependent-pair-types -open import foundation.disjunction open import foundation.existential-quantification open import foundation.function-types -open import foundation.inhabited-types open import foundation.negation open import foundation.universal-quantification open import foundation.universe-levels -open import foundation-core.identity-types open import foundation-core.propositions -open import foundation-core.sets - -open import univalent-combinatorics.standard-finite-types ```
@@ -91,6 +82,10 @@ module _ > This remains to be formalized. +### Types with decidability search are markovian + +> This remains to be formalized. + ## See also - [Markov's principle](logic.markovs-principle.md) diff --git a/src/logic/propositional-double-negation-elimination.lagda.md b/src/logic/propositional-double-negation-elimination.lagda.md new file mode 100644 index 0000000000..4f81b3f93e --- /dev/null +++ b/src/logic/propositional-double-negation-elimination.lagda.md @@ -0,0 +1,269 @@ +# Propositional double negation elimination + +```agda +module logic.propositional-double-negation-elimination where +``` + +
Imports + +```agda +open import foundation.cartesian-product-types +open import foundation.coproduct-types +open import foundation.decidable-types +open import foundation.dependent-pair-types +open import foundation.double-negation +open import foundation.empty-types +open import foundation.functoriality-propositional-truncation +open import foundation.irrefutable-equality +open import foundation.logical-equivalences +open import foundation.mere-equality +open import foundation.negation +open import foundation.propositional-truncations +open import foundation.retracts-of-types +open import foundation.transport-along-identifications +open import foundation.universe-levels + +open import foundation-core.equivalences +open import foundation-core.function-types +open import foundation-core.propositions + +open import logic.double-negation-elimination +open import logic.propositionally-decidable-types +``` + +
+ +## Idea + +We say a type `A` satisfies +{{#concept "propositional double negation elimination" Disambiguation="on a type" Agda=has-prop-double-negation-elim}} +if the implication + +```text + ¬¬A ⇒ ║A║₋₁ +``` + +holds. + +## Definitions + +### Propositional double negation elimination + +```agda +module _ + {l : Level} (A : UU l) + where + + has-prop-double-negation-elim : UU l + has-prop-double-negation-elim = ¬¬ A → ║ A ║₋₁ + + is-prop-has-prop-double-negation-elim : is-prop has-prop-double-negation-elim + is-prop-has-prop-double-negation-elim = + is-prop-function-type is-prop-type-trunc-Prop + + has-prop-double-negation-elim-Prop : Prop l + has-prop-double-negation-elim-Prop = + ( has-prop-double-negation-elim , is-prop-has-prop-double-negation-elim) +``` + +## Properties + +### Propositional double negation elimination is preserved by logical equivalences + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + has-prop-double-negation-elim-iff : + A ↔ B → has-prop-double-negation-elim B → has-prop-double-negation-elim A + has-prop-double-negation-elim-iff e H = + map-trunc-Prop (backward-implication e) ∘ + H ∘ + map-double-negation (forward-implication e) + + has-prop-double-negation-elim-iff' : + B ↔ A → has-prop-double-negation-elim B → has-prop-double-negation-elim A + has-prop-double-negation-elim-iff' e = + has-prop-double-negation-elim-iff (inv-iff e) +``` + +### Propositional double negation elimination is preserved by equivalences + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + has-prop-double-negation-elim-equiv : + A ≃ B → has-prop-double-negation-elim B → has-prop-double-negation-elim A + has-prop-double-negation-elim-equiv e = + has-prop-double-negation-elim-iff (iff-equiv e) + + has-prop-double-negation-elim-equiv' : + B ≃ A → has-prop-double-negation-elim B → has-prop-double-negation-elim A + has-prop-double-negation-elim-equiv' e = + has-prop-double-negation-elim-iff' (iff-equiv e) +``` + +### Propositional double negation elimination is preserved by retracts + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + has-prop-double-negation-elim-retract : + A retract-of B → + has-prop-double-negation-elim B → has-prop-double-negation-elim A + has-prop-double-negation-elim-retract e = + has-prop-double-negation-elim-iff (iff-retract e) + + has-prop-double-negation-elim-retract' : + B retract-of A → + has-prop-double-negation-elim B → has-prop-double-negation-elim A + has-prop-double-negation-elim-retract' e = + has-prop-double-negation-elim-iff' (iff-retract e) +``` + +### If the negation of a type with double negation elimination is decidable, then the type is merely decidable + +```agda +module _ + {l1 : Level} {A : UU l1} + where + + is-inhabited-or-empty-is-decidable-neg-has-prop-double-negation-elim : + has-prop-double-negation-elim A → + is-decidable (¬ A) → + is-inhabited-or-empty A + is-inhabited-or-empty-is-decidable-neg-has-prop-double-negation-elim f + ( inl nx) = + inr nx + is-inhabited-or-empty-is-decidable-neg-has-prop-double-negation-elim f + ( inr nnx) = + inl (f nnx) +``` + +**Remark.** It is an established fact that both the property of satisfying +double negation elimination, and the property of having decidable negation, are +strictly weaker conditions than being decidable. Therefore, this result +demonstrates that they are independent too. + +### Types with double negation elimination satisfy propositional double negation elimination + +```agda +has-prop-double-negation-elim-has-double-negation-elim : + {l : Level} {A : UU l} → + has-double-negation-elim A → + has-prop-double-negation-elim A +has-prop-double-negation-elim-has-double-negation-elim H = unit-trunc-Prop ∘ H +``` + +### Propositional double negation elimination for merely decidable types + +```agda +prop-double-negation-elim-is-inhabited-or-empty : + {l : Level} {A : UU l} → + is-inhabited-or-empty A → has-prop-double-negation-elim A +prop-double-negation-elim-is-inhabited-or-empty (inl |a|) _ = |a| +prop-double-negation-elim-is-inhabited-or-empty (inr na) nna = ex-falso (nna na) +``` + +### Propositional double negation elimination for dependent sums + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} + where + + has-prop-double-negation-elim-Σ-has-double-negation-dense-equality-base : + has-double-negation-dense-equality A → + has-prop-double-negation-elim A → + ((x : A) → has-prop-double-negation-elim (B x)) → + has-prop-double-negation-elim (Σ A B) + has-prop-double-negation-elim-Σ-has-double-negation-dense-equality-base + H f g nnab = + rec-trunc-Prop + ( trunc-Prop (Σ A B)) + ( λ a → + rec-trunc-Prop + ( trunc-Prop (Σ A B)) + ( λ b → unit-trunc-Prop (a , b)) + ( g a (λ nb → nnab (λ x → H (pr1 x) a (λ p → nb (tr B p (pr2 x))))))) + ( f (map-double-negation pr1 nnab)) + + has-prop-double-negation-elim-Σ-all-elements-merely-equal-base : + all-elements-merely-equal A → + has-prop-double-negation-elim A → + ((x : A) → has-prop-double-negation-elim (B x)) → + has-prop-double-negation-elim (Σ A B) + has-prop-double-negation-elim-Σ-all-elements-merely-equal-base H = + has-prop-double-negation-elim-Σ-has-double-negation-dense-equality-base + ( λ x y → + double-negation-double-negation-type-trunc-Prop + ( intro-double-negation (H x y))) + + has-prop-double-negation-elim-Σ-is-prop-base : + is-prop A → + has-prop-double-negation-elim A → + ((x : A) → has-prop-double-negation-elim (B x)) → + has-prop-double-negation-elim (Σ A B) + has-prop-double-negation-elim-Σ-is-prop-base is-prop-A = + has-prop-double-negation-elim-Σ-all-elements-merely-equal-base + ( λ x y → unit-trunc-Prop (eq-is-prop is-prop-A)) + + has-prop-double-negation-elim-base-Σ-section' : + has-prop-double-negation-elim (Σ A B) → + (A → Σ A B) → + has-prop-double-negation-elim A + has-prop-double-negation-elim-base-Σ-section' H f nna = + map-trunc-Prop pr1 (H (λ nab → nna (λ x → nab (f x)))) + + has-prop-double-negation-elim-base-Σ-section : + has-prop-double-negation-elim (Σ A B) → + ((x : A) → B x) → + has-prop-double-negation-elim A + has-prop-double-negation-elim-base-Σ-section H f = + has-prop-double-negation-elim-base-Σ-section' H (λ x → x , f x) + + has-prop-double-negation-elim-family-Σ-all-elements-merely-equal-base : + has-prop-double-negation-elim (Σ A B) → + all-elements-merely-equal A → + (x : A) → has-prop-double-negation-elim (B x) + has-prop-double-negation-elim-family-Σ-all-elements-merely-equal-base + K q x nnb = + rec-trunc-Prop + ( trunc-Prop (B x)) + ( λ xy → + rec-trunc-Prop + ( trunc-Prop (B x)) + ( λ p → unit-trunc-Prop (tr B p (pr2 xy))) + ( q (pr1 xy) x)) + ( K (λ nab → nnb (λ y → nab (x , y)))) +``` + +### Double negation elimination for products of types with double negation elimination + +```agda +has-prop-double-negation-elim-product : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → + has-prop-double-negation-elim A → + has-prop-double-negation-elim B → + has-prop-double-negation-elim (A × B) +has-prop-double-negation-elim-product {A = A} {B} f g nnab = + rec-trunc-Prop + ( trunc-Prop (A × B)) + ( λ a → + rec-trunc-Prop + ( trunc-Prop (A × B)) + ( λ b → unit-trunc-Prop (a , b)) + ( g (map-double-negation pr2 nnab))) + ( f (map-double-negation pr1 nnab)) +``` + +## See also + +- [The double negation modality](foundation.double-negation-modality.md) +- [Irrefutable propositions](foundation.irrefutable-propositions.md) are double + negation connected types. diff --git a/src/logic/propositionally-decidable-maps.lagda.md b/src/logic/propositionally-decidable-maps.lagda.md new file mode 100644 index 0000000000..8bfa67b800 --- /dev/null +++ b/src/logic/propositionally-decidable-maps.lagda.md @@ -0,0 +1,187 @@ +# Propositionally decidable maps + +```agda +module logic.propositionally-decidable-maps where +``` + +
Imports + +```agda +open import elementary-number-theory.natural-numbers + +open import foundation.coproduct-types +open import foundation.decidable-dependent-pair-types +open import foundation.decidable-maps +open import foundation.dependent-pair-types +open import foundation.double-negation-dense-equality-maps +open import foundation.identity-types +open import foundation.propositional-truncations +open import foundation.universe-levels + +open import foundation-core.fibers-of-maps +open import foundation-core.function-types +open import foundation-core.functoriality-dependent-pair-types +open import foundation-core.homotopies +open import foundation-core.injective-maps +open import foundation-core.iterating-functions + +open import logic.propositionally-decidable-types +``` + +
+ +## Idea + +A [map](foundation-core.function-types.md) is said to be +{{#concept "propositionally decidable" Disambiguation="map of types" Agda=is-inhabited-or-empty-map}} +if its [fibers](foundation-core.fibers-of-maps.md) are +[propositionally decidable types](logic.propositionally-decidable-types.md), +i.e., if they are merely [inhabited](foundation.inhabited-types.md) or +[empty](foundation.empty-types.md). + +## Definitions + +### The propositional decidability predicate on a map + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-inhabited-or-empty-map : (A → B) → UU (l1 ⊔ l2) + is-inhabited-or-empty-map f = (y : B) → is-inhabited-or-empty (fiber f y) +``` + +### The type of propositionally decidable maps + +```agda +inhabited-or-empty-map : {l1 l2 : Level} (A : UU l1) (B : UU l2) → UU (l1 ⊔ l2) +inhabited-or-empty-map A B = Σ (A → B) (is-inhabited-or-empty-map) + +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} (f : inhabited-or-empty-map A B) + where + + map-inhabited-or-empty-map : A → B + map-inhabited-or-empty-map = pr1 f + + is-decidable-inhabited-or-empty-map : + is-inhabited-or-empty-map map-inhabited-or-empty-map + is-decidable-inhabited-or-empty-map = pr2 f +``` + +## Properties + +### Propositionally decidable maps are closed under homotopy + +```agda +abstract + is-inhabited-or-empty-map-htpy : + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f g : A → B} → + f ~ g → is-inhabited-or-empty-map g → is-inhabited-or-empty-map f + is-inhabited-or-empty-map-htpy H K b = + is-inhabited-or-empty-equiv + ( equiv-tot (λ a → equiv-concat (inv (H a)) b)) + ( K b) +``` + +### Decidable maps are propositionally decidable + +```agda +is-inhabited-or-empty-map-is-decidable-map : + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} → + is-decidable-map f → is-inhabited-or-empty-map f +is-inhabited-or-empty-map-is-decidable-map H x = + is-inhabited-or-empty-is-decidable (H x) +``` + +### The identity map is propositionally decidable + +```agda +abstract + is-inhabited-or-empty-map-id : + {l : Level} {X : UU l} → is-inhabited-or-empty-map (id {l} {X}) + is-inhabited-or-empty-map-id y = inl (unit-trunc-Prop (y , refl)) +``` + +### Composition of propositionally decidable maps + +The composite `g ∘ f` of two propositionally decidable maps is propositionally +decidable if `g` is injective. + +```agda +module _ + {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {C : UU l3} + {g : B → C} {f : A → B} + where + + abstract + is-inhabited-or-empty-map-comp : + is-injective g → + is-inhabited-or-empty-map g → + is-inhabited-or-empty-map f → + is-inhabited-or-empty-map (g ∘ f) + is-inhabited-or-empty-map-comp H G F x = + is-inhabited-or-empty-equiv + ( compute-fiber-comp g f x) + ( elim-is-inhabited-or-empty-Prop + ( is-inhabited-or-empty-Prop + ( Σ (fiber g x) (fiber f ∘ pr1))) + ( λ t → + elim-is-inhabited-or-empty-Prop + ( is-inhabited-or-empty-Prop (Σ (fiber g x) (fiber f ∘ pr1))) + ( λ s → inl (unit-trunc-Prop (t , s))) + ( λ ns → + inr + ( λ ts → + ns + ( pr1 (pr2 ts) , + pr2 (pr2 ts) ∙ H ((pr2 (pr1 ts)) ∙ inv (pr2 t))))) + ( F (pr1 t))) + ( λ nt → inr (λ ts → nt (pr1 ts))) + ( G x)) +``` + +The composite `g ∘ f` of two propositionally decidable maps is propositionally +decidable if `g` has double negation dense equality. + +```agda +module _ + {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} {C : UU l3} + {g : B → C} {f : A → B} + where + + abstract + is-inhabited-or-empty-map-comp-has-double-negation-dense-equality-map : + has-double-negation-dense-equality-map g → + is-inhabited-or-empty-map g → + is-inhabited-or-empty-map f → + is-inhabited-or-empty-map (g ∘ f) + is-inhabited-or-empty-map-comp-has-double-negation-dense-equality-map + H G F x = + is-inhabited-or-empty-equiv + ( compute-fiber-comp g f x) + ( is-inhabited-or-empty-Σ-has-double-negation-dense-equality-base + ( H x) + ( G x) + ( F ∘ pr1)) + +module _ + {l1 : Level} {A : UU l1} {f : A → A} + (is-inhabited-or-empty-f : is-inhabited-or-empty-map f) + (F : has-double-negation-dense-equality-map f) + where + + is-inhabited-or-empty-map-iterate-has-double-negation-dense-equality-map : + (n : ℕ) → is-inhabited-or-empty-map (iterate n f) + is-inhabited-or-empty-map-iterate-has-double-negation-dense-equality-map + zero-ℕ = + is-inhabited-or-empty-map-id + is-inhabited-or-empty-map-iterate-has-double-negation-dense-equality-map + ( succ-ℕ n) = + is-inhabited-or-empty-map-comp-has-double-negation-dense-equality-map + ( F) + ( is-inhabited-or-empty-f) + ( is-inhabited-or-empty-map-iterate-has-double-negation-dense-equality-map + ( n)) +``` diff --git a/src/logic/propositionally-decidable-types.lagda.md b/src/logic/propositionally-decidable-types.lagda.md new file mode 100644 index 0000000000..400e949a3b --- /dev/null +++ b/src/logic/propositionally-decidable-types.lagda.md @@ -0,0 +1,362 @@ +# Propositionally decidable types + +```agda +module logic.propositionally-decidable-types where +``` + +
Imports + +```agda +open import foundation.coinhabited-pairs-of-types +open import foundation.coproduct-types +open import foundation.decidable-types +open import foundation.dependent-pair-types +open import foundation.empty-types +open import foundation.equivalences +open import foundation.functoriality-coproduct-types +open import foundation.logical-equivalences +open import foundation.negation +open import foundation.propositional-truncations +open import foundation.retracts-of-types +open import foundation.universe-levels + +open import foundation-core.cartesian-product-types +open import foundation-core.decidable-propositions +open import foundation-core.function-types +open import foundation-core.propositions +``` + +
+ +## Idea + +A type is said to be +{{#concept "propositionally decidable" Disambiguation="type" Agda=is-inhabited-or-empty}} +if we can either deduce that it is [inhabited](foundation.inhabited-types.md), +or we can deduce that it is [empty](foundation-core.empty-types.md), where +inhabitedness of a type is expressed using the +[propositional truncation](foundation.propositional-truncations.md). + +## Definitions + +### The predicate that a type is inhabited or empty + +```agda +is-inhabited-or-empty : {l1 : Level} → UU l1 → UU l1 +is-inhabited-or-empty A = type-trunc-Prop A + is-empty A +``` + +### Merely decidable types + +A type `A` is said to be +{{#concept "merely decidable" Agda=is-merely-decidable}} if it comes equipped +with an element of `║ is-decidable A ║₋₁`, or equivalently, the +[disjunction](foundation.disjunction.md) `A ∨ ¬ A` holds. + +```agda +is-merely-decidable-Prop : + {l : Level} → UU l → Prop l +is-merely-decidable-Prop A = trunc-Prop (is-decidable A) + +is-merely-decidable : {l : Level} → UU l → UU l +is-merely-decidable A = type-trunc-Prop (is-decidable A) +``` + +## Properties + +### Decidable types are inhabited or empty + +```agda +is-inhabited-or-empty-is-decidable : + {l : Level} {A : UU l} → is-decidable A → is-inhabited-or-empty A +is-inhabited-or-empty-is-decidable (inl x) = inl (unit-trunc-Prop x) +is-inhabited-or-empty-is-decidable (inr y) = inr y +``` + +### Decidable types are merely decidable + +```agda +is-merely-decidable-is-decidable : + {l : Level} {A : UU l} → is-decidable A → is-merely-decidable A +is-merely-decidable-is-decidable = unit-trunc-Prop +``` + +### Being inhabited or empty is a proposition + +```agda +abstract + is-property-is-inhabited-or-empty : + {l1 : Level} (A : UU l1) → is-prop (is-inhabited-or-empty A) + is-property-is-inhabited-or-empty A = + is-prop-coproduct + ( λ t → apply-universal-property-trunc-Prop t empty-Prop) + ( is-prop-type-trunc-Prop) + ( is-prop-neg) + +is-inhabited-or-empty-Prop : {l1 : Level} → UU l1 → Prop l1 +pr1 (is-inhabited-or-empty-Prop A) = is-inhabited-or-empty A +pr2 (is-inhabited-or-empty-Prop A) = is-property-is-inhabited-or-empty A +``` + +### Types are inhabited or empty if and only if they are merely decidable + +```agda +module _ + {l : Level} {A : UU l} + where + + is-inhabited-or-empty-is-merely-decidable : + is-merely-decidable A → is-inhabited-or-empty A + is-inhabited-or-empty-is-merely-decidable = + rec-trunc-Prop + ( is-inhabited-or-empty-Prop A) + ( is-inhabited-or-empty-is-decidable) + + is-merely-decidable-is-inhabited-or-empty : + is-inhabited-or-empty A → is-merely-decidable A + is-merely-decidable-is-inhabited-or-empty (inl |x|) = + rec-trunc-Prop (is-merely-decidable-Prop A) (unit-trunc-Prop ∘ inl) |x| + is-merely-decidable-is-inhabited-or-empty (inr y) = + unit-trunc-Prop (inr y) + + iff-is-inhabited-or-empty-is-merely-decidable : + is-merely-decidable A ↔ is-inhabited-or-empty A + iff-is-inhabited-or-empty-is-merely-decidable = + ( is-inhabited-or-empty-is-merely-decidable , + is-merely-decidable-is-inhabited-or-empty) +``` + +### Propositionally decidable types are closed under coinhabited types + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-inhabited-or-empty-is-coinhabited : + is-coinhabited A B → is-inhabited-or-empty A → is-inhabited-or-empty B + is-inhabited-or-empty-is-coinhabited (f , b) = + map-coproduct + ( f) + ( is-empty-type-trunc-Prop' ∘ map-neg b ∘ is-empty-type-trunc-Prop) +``` + +### Propositionally decidable types are closed under logical equivalences + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-inhabited-or-empty-iff : + (A → B) → (B → A) → is-inhabited-or-empty A → is-inhabited-or-empty B + is-inhabited-or-empty-iff f g (inl |a|) = + inl (rec-trunc-Prop (trunc-Prop B) (unit-trunc-Prop ∘ f) |a|) + is-inhabited-or-empty-iff f g (inr na) = inr (na ∘ g) + + is-inhabited-or-empty-iff' : + A ↔ B → is-inhabited-or-empty A → is-inhabited-or-empty B + is-inhabited-or-empty-iff' (f , g) = is-inhabited-or-empty-iff f g + +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + iff-is-inhabited-or-empty : + A ↔ B → is-inhabited-or-empty A ↔ is-inhabited-or-empty B + iff-is-inhabited-or-empty e = + is-inhabited-or-empty-iff' e , is-inhabited-or-empty-iff' (inv-iff e) +``` + +### Propositionally decidable types are closed under retracts + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-inhabited-or-empty-retract-of : + A retract-of B → is-inhabited-or-empty B → is-inhabited-or-empty A + is-inhabited-or-empty-retract-of R = + is-inhabited-or-empty-iff' (iff-retract' R) + + is-inhabited-or-empty-retract-of' : + A retract-of B → is-inhabited-or-empty A → is-inhabited-or-empty B + is-inhabited-or-empty-retract-of' R = + is-inhabited-or-empty-iff' (inv-iff (iff-retract' R)) +``` + +### Propositionally decidable types are closed under equivalences + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-inhabited-or-empty-is-equiv : + {f : A → B} → is-equiv f → is-inhabited-or-empty B → is-inhabited-or-empty A + is-inhabited-or-empty-is-equiv {f} H = + is-inhabited-or-empty-retract-of (retract-equiv (f , H)) + + is-inhabited-or-empty-equiv : + A ≃ B → is-inhabited-or-empty B → is-inhabited-or-empty A + is-inhabited-or-empty-equiv e = + is-inhabited-or-empty-iff (map-inv-equiv e) (map-equiv e) + + is-inhabited-or-empty-equiv' : + A ≃ B → is-inhabited-or-empty A → is-inhabited-or-empty B + is-inhabited-or-empty-equiv' e = + is-inhabited-or-empty-iff (map-equiv e) (map-inv-equiv e) +``` + +### Elimination for propositional decidability + +```agda +module _ + {l1 l2 : Level} {A : UU l1} (B : Prop l2) + where + + elim-is-inhabited-or-empty-Prop : + (A → type-Prop B) → (¬ A → type-Prop B) → + is-inhabited-or-empty A → type-Prop B + elim-is-inhabited-or-empty-Prop b nb (inl |a|) = rec-trunc-Prop B b |a| + elim-is-inhabited-or-empty-Prop b nb (inr na) = nb na + + elim-is-inhabited-or-empty-Prop' : + (is-decidable A → type-Prop B) → is-inhabited-or-empty A → type-Prop B + elim-is-inhabited-or-empty-Prop' f = + elim-is-inhabited-or-empty-Prop (f ∘ inl) (f ∘ inr) +``` + +### Coproducts of propositionally decidable types are propositionally decidable + +```agda +is-inhabited-or-empty-coproduct : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → + is-inhabited-or-empty A → + is-inhabited-or-empty B → + is-inhabited-or-empty (A + B) +is-inhabited-or-empty-coproduct (inl a) dB = + rec-trunc-Prop (is-inhabited-or-empty-Prop _) (inl ∘ unit-trunc-Prop ∘ inl) a +is-inhabited-or-empty-coproduct (inr na) (inl b) = + rec-trunc-Prop (is-inhabited-or-empty-Prop _) (inl ∘ unit-trunc-Prop ∘ inr) b +is-inhabited-or-empty-coproduct (inr na) (inr nb) = inr (rec-coproduct na nb) +``` + +### Cartesian products of propositionally decidable types are propositionally decidable + +```agda +is-inhabited-or-empty-product : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → + is-inhabited-or-empty A → + is-inhabited-or-empty B → + is-inhabited-or-empty (A × B) +is-inhabited-or-empty-product (inl a) (inl b) = + inl (map-inv-distributive-trunc-product-Prop (a , b)) +is-inhabited-or-empty-product (inl a) (inr nb) = inr (nb ∘ pr2) +is-inhabited-or-empty-product (inr na) dB = inr (na ∘ pr1) + +is-inhabited-or-empty-product' : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → + is-inhabited-or-empty A → (A → is-inhabited-or-empty B) → + is-inhabited-or-empty (A × B) +is-inhabited-or-empty-product' (inl a) dB = + rec-trunc-Prop + ( is-inhabited-or-empty-Prop _) + ( rec-coproduct + ( λ b → inl (map-inv-distributive-trunc-product-Prop (a , b))) + ( λ nb → inr (nb ∘ pr2)) ∘ + dB) + ( a) +is-inhabited-or-empty-product' (inr na) dB = inr (na ∘ pr1) + +is-inhabited-or-empty-left-factor : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → + is-inhabited-or-empty (A × B) → B → is-inhabited-or-empty A +is-inhabited-or-empty-left-factor (inl x) b = + inl (pr1 (map-distributive-trunc-product-Prop x)) +is-inhabited-or-empty-left-factor (inr nx) b = inr (λ a → nx (a , b)) + +is-inhabited-or-empty-right-factor : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → + is-inhabited-or-empty (A × B) → A → is-inhabited-or-empty B +is-inhabited-or-empty-right-factor (inl x) a = + inl (pr2 (map-distributive-trunc-product-Prop x)) +is-inhabited-or-empty-right-factor (inr nx) a = inr (λ b → nx (a , b)) +``` + +### Function types of propositionally decidable types are propositionally decidable + +```agda +is-inhabited-or-empty-function-type : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → + is-inhabited-or-empty A → + is-inhabited-or-empty B → + is-inhabited-or-empty (A → B) +is-inhabited-or-empty-function-type (inl a) (inl b) = + inl (rec-trunc-Prop (trunc-Prop _) (λ y → unit-trunc-Prop (λ _ → y)) b) +is-inhabited-or-empty-function-type (inl a) (inr nb) = + inr (λ f → rec-trunc-Prop empty-Prop (λ x → nb (f x)) a) +is-inhabited-or-empty-function-type (inr na) dB = + inl (unit-trunc-Prop (ex-falso ∘ na)) + +is-inhabited-or-empty-function-type' : + {l1 l2 : Level} {A : UU l1} {B : UU l2} → + is-inhabited-or-empty A → (A → is-inhabited-or-empty B) → + is-inhabited-or-empty (A → B) +is-inhabited-or-empty-function-type' (inl a) dB = + rec-trunc-Prop (is-inhabited-or-empty-Prop _) + ( λ x → + rec-coproduct + ( inl ∘ rec-trunc-Prop (trunc-Prop _) (λ y → unit-trunc-Prop (λ _ → y))) + ( λ nb → inr (λ f → nb (f x))) + ( dB x)) + ( a) +is-inhabited-or-empty-function-type' (inr na) dB = + inl (unit-trunc-Prop (ex-falso ∘ na)) +``` + +### Decidability of a propositional truncation + +```agda +abstract + is-prop-is-decidable-trunc-Prop : + {l : Level} (A : UU l) → is-prop (is-decidable (type-trunc-Prop A)) + is-prop-is-decidable-trunc-Prop A = + is-prop-is-decidable is-prop-type-trunc-Prop + +is-decidable-trunc-Prop : {l : Level} → UU l → Prop l +pr1 (is-decidable-trunc-Prop A) = is-decidable (type-trunc-Prop A) +pr2 (is-decidable-trunc-Prop A) = is-prop-is-decidable-trunc-Prop A + +is-decidable-trunc-Prop-is-decidable : + {l : Level} {A : UU l} → + is-decidable A → type-Prop (is-decidable-trunc-Prop A) +is-decidable-trunc-Prop-is-decidable (inl a) = + inl (unit-trunc-Prop a) +is-decidable-trunc-Prop-is-decidable (inr f) = + inr (map-universal-property-trunc-Prop empty-Prop f) + +is-decidable-trunc-Prop-is-merely-decidable : + {l : Level} {A : UU l} → + is-merely-decidable A → is-decidable (type-trunc-Prop A) +is-decidable-trunc-Prop-is-merely-decidable {A = A} = + map-universal-property-trunc-Prop + ( is-decidable-trunc-Prop A) + ( is-decidable-trunc-Prop-is-decidable) + +is-merely-decidable-is-decidable-trunc-Prop : + {l : Level} (A : UU l) → + is-decidable (type-trunc-Prop A) → is-merely-decidable A +is-merely-decidable-is-decidable-trunc-Prop A (inl x) = + apply-universal-property-trunc-Prop x + ( is-merely-decidable-Prop A) + ( unit-trunc-Prop ∘ inl) +is-merely-decidable-is-decidable-trunc-Prop A (inr f) = + unit-trunc-Prop (inr (f ∘ unit-trunc-Prop)) +``` + +## See also + +- That decidablity is irrefutable is shown in + [`foundation.irrefutable-propositions`](foundation.irrefutable-propositions.md). diff --git a/src/logic/propositionally-double-negation-eliminating-maps.lagda.md b/src/logic/propositionally-double-negation-eliminating-maps.lagda.md new file mode 100644 index 0000000000..446cfea6f7 --- /dev/null +++ b/src/logic/propositionally-double-negation-eliminating-maps.lagda.md @@ -0,0 +1,124 @@ +# Propositionally double negation eliminating maps + +```agda +module logic.propositionally-double-negation-eliminating-maps where +``` + +
Imports + +```agda +open import foundation.dependent-pair-types +open import foundation.identity-types +open import foundation.propositions +open import foundation.universe-levels + +open import foundation-core.fibers-of-maps +open import foundation-core.functoriality-dependent-pair-types +open import foundation-core.homotopies + +open import logic.double-negation-eliminating-maps +open import logic.propositional-double-negation-elimination +open import logic.propositionally-decidable-maps +``` + +
+ +## Idea + +A [map](foundation-core.function-types.md) is said to be +{{#concept "propositionally double negation eliminating" Disambiguation="map of types" Agda=is-prop-double-negation-eliminating-map}} +if its [fibers](foundation-core.fibers-of-maps.md) satisfy +[propositional double negation elimination](logic.propositional-double-negation-elimination.md). +I.e., for every `y : B`, if `fiber f y` is +[irrefutable](foundation.irrefutable-propositions.md), then we have then the +fiber is in fact inhabited. In other words, double negation eliminating maps +come [equipped](foundation.structure.md) with a map + +```text + (y : B) → ¬¬ (fiber f y) → ║ fiber f y ║₋₁. +``` + +## Definintion + +### Propositional double negation elimination on a map + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-prop-double-negation-eliminating-map : (A → B) → UU (l1 ⊔ l2) + is-prop-double-negation-eliminating-map f = + (y : B) → has-prop-double-negation-elim (fiber f y) + + is-property-is-prop-double-negation-eliminating-map : + {f : A → B} → is-prop (is-prop-double-negation-eliminating-map f) + is-property-is-prop-double-negation-eliminating-map {f} = + is-prop-Π (λ y → is-prop-has-prop-double-negation-elim (fiber f y)) + + is-prop-double-negation-eliminating-map-Prop : (A → B) → Prop (l1 ⊔ l2) + is-prop-double-negation-eliminating-map-Prop f = + is-prop-double-negation-eliminating-map f , + is-property-is-prop-double-negation-eliminating-map +``` + +### The type of propositionally double negation eliminating maps + +```agda +prop-double-negation-eliminating-map : + {l1 l2 : Level} (A : UU l1) (B : UU l2) → UU (l1 ⊔ l2) +prop-double-negation-eliminating-map A B = + Σ (A → B) (is-prop-double-negation-eliminating-map) + +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + (f : prop-double-negation-eliminating-map A B) + where + + map-prop-double-negation-eliminating-map : A → B + map-prop-double-negation-eliminating-map = pr1 f + + is-prop-double-negation-eliminating-prop-double-negation-eliminating-map : + is-prop-double-negation-eliminating-map + map-prop-double-negation-eliminating-map + is-prop-double-negation-eliminating-prop-double-negation-eliminating-map = + pr2 f +``` + +## Properties + +### Propositionally double negation eliminating maps are closed under homotopy + +```agda +abstract + is-prop-double-negation-eliminating-map-htpy : + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f g : A → B} → + f ~ g → + is-prop-double-negation-eliminating-map g → + is-prop-double-negation-eliminating-map f + is-prop-double-negation-eliminating-map-htpy H K b = + has-prop-double-negation-elim-equiv + ( equiv-tot (λ a → equiv-concat (inv (H a)) b)) + ( K b) +``` + +### Double negation eliminating maps are propositionally double negation eliminating + +```agda +is-prop-double-negation-eliminating-map-is-double-negation-eliminating-map : + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} → + is-double-negation-eliminating-map f → + is-prop-double-negation-eliminating-map f +is-prop-double-negation-eliminating-map-is-double-negation-eliminating-map H y = + has-prop-double-negation-elim-has-double-negation-elim (H y) +``` + +### Propositionally decidable maps are propositionally double negation eliminating + +```agda +is-prop-double-negation-eliminating-map-is-inhabited-or-empty-map : + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} → + is-inhabited-or-empty-map f → is-prop-double-negation-eliminating-map f +is-prop-double-negation-eliminating-map-is-inhabited-or-empty-map H y = + prop-double-negation-elim-is-inhabited-or-empty (H y) +``` diff --git a/src/synthetic-homotopy-theory/homotopy-groups.lagda.md b/src/synthetic-homotopy-theory/homotopy-groups.lagda.md index 5d30f801f9..e6f739ed10 100644 --- a/src/synthetic-homotopy-theory/homotopy-groups.lagda.md +++ b/src/synthetic-homotopy-theory/homotopy-groups.lagda.md @@ -37,8 +37,8 @@ where - `π₀ A` is the set of [connected components](foundation.connected-components.md) of `A`, and - `πᵢ₊₁ A` is the set `πᵢ ΩA` equipped with the - [group structure](group-theory.groups.md) obtained from the [loop - space](synthetic-homotopy theory.loop-spaces.md). + [group structure](group-theory.groups.md) obtained from the + [loop space](synthetic-homotopy-theory.loop-spaces.md). For `i ≥ 2`, the `i`-th homotopy group `πᵢ A` of `A` is [abelian](group-theory.abelian-groups.md) by the diff --git a/src/trees.lagda.md b/src/trees.lagda.md index 4da5e8d445..f3dd773448 100644 --- a/src/trees.lagda.md +++ b/src/trees.lagda.md @@ -4,7 +4,7 @@ {-# OPTIONS --guardedness #-} ``` -## Files in the `trees` module +## Modules in the trees namespace ```agda module trees where diff --git a/src/univalent-combinatorics/counting.lagda.md b/src/univalent-combinatorics/counting.lagda.md index b9c4fa6d19..79b55c6a18 100644 --- a/src/univalent-combinatorics/counting.lagda.md +++ b/src/univalent-combinatorics/counting.lagda.md @@ -26,6 +26,8 @@ open import foundation.sets open import foundation.unit-type open import foundation.universe-levels +open import logic.propositionally-decidable-types + open import univalent-combinatorics.equality-standard-finite-types open import univalent-combinatorics.standard-finite-types ``` diff --git a/src/univalent-combinatorics/decidable-dependent-function-types.lagda.md b/src/univalent-combinatorics/decidable-dependent-function-types.lagda.md index 5f6cfff00c..c9e717f084 100644 --- a/src/univalent-combinatorics/decidable-dependent-function-types.lagda.md +++ b/src/univalent-combinatorics/decidable-dependent-function-types.lagda.md @@ -62,7 +62,7 @@ is-decidable-Π-is-finite : ((x : A) → is-decidable (B x)) → is-decidable ((x : A) → B x) is-decidable-Π-is-finite {l1} {l2} {A} {B} H d = is-decidable-iff - ( map-Π (λ x → elim-trunc-Prop-is-decidable (d x))) + ( map-Π (λ x → ε-operator-is-decidable (d x))) ( map-Π (λ x → unit-trunc-Prop)) ( is-decidable-iff ( α) @@ -77,7 +77,7 @@ is-decidable-Π-is-finite {l1} {l2} {A} {B} H d = ( λ x → is-decidable-iff ( unit-trunc-Prop) - ( elim-trunc-Prop-is-decidable (d x)) + ( ε-operator-is-decidable (d x)) ( d x)))))) where α : type-trunc-Prop ((x : A) → B x) → (x : A) → type-trunc-Prop (B x) diff --git a/src/univalent-combinatorics/dependent-pair-types.lagda.md b/src/univalent-combinatorics/dependent-pair-types.lagda.md index 491d05e318..8656055338 100644 --- a/src/univalent-combinatorics/dependent-pair-types.lagda.md +++ b/src/univalent-combinatorics/dependent-pair-types.lagda.md @@ -31,6 +31,8 @@ open import foundation.type-arithmetic-coproduct-types open import foundation.type-arithmetic-dependent-pair-types open import foundation.universe-levels +open import logic.propositionally-decidable-types + open import univalent-combinatorics.coproduct-types open import univalent-combinatorics.counting open import univalent-combinatorics.counting-dependent-pair-types diff --git a/src/univalent-combinatorics/finite-types.lagda.md b/src/univalent-combinatorics/finite-types.lagda.md index 0ddff4cb5a..ab9b151fe7 100644 --- a/src/univalent-combinatorics/finite-types.lagda.md +++ b/src/univalent-combinatorics/finite-types.lagda.md @@ -42,6 +42,8 @@ open import foundation.universe-levels open import foundation-core.torsorial-type-families +open import logic.propositionally-decidable-types + open import univalent-combinatorics.counting open import univalent-combinatorics.double-counting open import univalent-combinatorics.standard-finite-types From 4621edc0da59af17697aef789ddf7c7ea326a654 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Fri, 28 Mar 2025 15:10:34 +0000 Subject: [PATCH 02/20] pull more edits from `logic-compactness` --- src/foundation-core.lagda.md | 1 + .../decidable-propositions.lagda.md | 128 ++++++++++++------ src/foundation-core/homotopies.lagda.md | 3 +- src/foundation-core/identity-types.lagda.md | 11 +- src/foundation-core/injective-maps.lagda.md | 62 +++++++-- .../iterating-functions.lagda.md | 123 +++++++++++++++++ src/foundation-core/subtypes.lagda.md | 4 + ...ecidable-dependent-function-types.lagda.md | 91 ------------- .../decidable-dependent-pair-types.lagda.md | 25 ---- src/foundation/decidable-types.lagda.md | 18 --- 10 files changed, 269 insertions(+), 197 deletions(-) create mode 100644 src/foundation-core/iterating-functions.lagda.md diff --git a/src/foundation-core.lagda.md b/src/foundation-core.lagda.md index 9b9dd2512c..ea01876a8c 100644 --- a/src/foundation-core.lagda.md +++ b/src/foundation-core.lagda.md @@ -36,6 +36,7 @@ open import foundation-core.homotopies public open import foundation-core.identity-types public open import foundation-core.injective-maps public open import foundation-core.invertible-maps public +open import foundation-core.iterating-functions public open import foundation-core.negation public open import foundation-core.operations-span-diagrams public open import foundation-core.operations-spans public diff --git a/src/foundation-core/decidable-propositions.lagda.md b/src/foundation-core/decidable-propositions.lagda.md index eb48a26b7d..6c69978020 100644 --- a/src/foundation-core/decidable-propositions.lagda.md +++ b/src/foundation-core/decidable-propositions.lagda.md @@ -12,9 +12,9 @@ open import foundation.decidable-types open import foundation.dependent-pair-types open import foundation.double-negation open import foundation.negation -open import foundation.propositional-truncations open import foundation.transport-along-identifications open import foundation.unit-type +open import foundation.universal-property-empty-type open import foundation.universe-levels open import foundation-core.cartesian-product-types @@ -23,6 +23,7 @@ open import foundation-core.empty-types open import foundation-core.function-types open import foundation-core.functoriality-dependent-pair-types open import foundation-core.propositions +open import foundation-core.sets open import foundation-core.subtypes ``` @@ -116,6 +117,9 @@ module _ is-decidable type-Decidable-Prop pr2 is-decidable-prop-Decidable-Prop = is-prop-is-decidable is-prop-type-Decidable-Prop + + set-Decidable-Prop : Set l + set-Decidable-Prop = set-Prop prop-Decidable-Prop ``` ### The empty type is a decidable proposition @@ -206,24 +210,25 @@ module _ is-decidable-is-decidable-prop-Σ : is-decidable (Σ P Q) is-decidable-is-decidable-prop-Σ = - rec-coproduct - ( λ x → - rec-coproduct - ( λ y → inl (x , y)) - ( λ ny → - inr - ( λ xy → - ny - ( tr Q - ( eq-is-prop (is-prop-type-is-decidable-prop H)) - ( pr2 xy)))) - ( is-decidable-type-is-decidable-prop (K x))) - ( λ nx → inr (λ xy → nx (pr1 xy))) + is-decidable-Σ-has-double-negation-dense-equality-base + ( λ x y → + intro-double-negation (eq-is-prop (is-prop-type-is-decidable-prop H))) ( is-decidable-type-is-decidable-prop H) + ( is-decidable-type-is-decidable-prop ∘ K) is-decidable-prop-Σ : is-decidable-prop (Σ P Q) is-decidable-prop-Σ = ( is-prop-is-decidable-prop-Σ , is-decidable-is-decidable-prop-Σ) + +Σ-Decidable-Prop : + {l1 l2 : Level} → + (P : Decidable-Prop l1) → + (type-Decidable-Prop P → Decidable-Prop l2) → Decidable-Prop (l1 ⊔ l2) +Σ-Decidable-Prop P Q = + ( Σ (type-Decidable-Prop P) (type-Decidable-Prop ∘ Q) , + is-decidable-prop-Σ + ( is-decidable-prop-type-Decidable-Prop P) + ( is-decidable-prop-type-Decidable-Prop ∘ Q)) ``` ### The negation operation on decidable propositions @@ -251,38 +256,71 @@ type-neg-Decidable-Prop : type-neg-Decidable-Prop P = type-Decidable-Prop (neg-Decidable-Prop P) ``` -### Decidability of a propositional truncation +### Function types between decidable propositions ```agda -abstract - is-prop-is-decidable-trunc-Prop : - {l : Level} (A : UU l) → is-prop (is-decidable (type-trunc-Prop A)) - is-prop-is-decidable-trunc-Prop A = - is-prop-is-decidable is-prop-type-trunc-Prop - -is-decidable-trunc-Prop : {l : Level} → UU l → Prop l -pr1 (is-decidable-trunc-Prop A) = is-decidable (type-trunc-Prop A) -pr2 (is-decidable-trunc-Prop A) = is-prop-is-decidable-trunc-Prop A - -is-decidable-trunc-Prop-is-merely-decidable : - {l : Level} (A : UU l) → - is-merely-decidable A → is-decidable (type-trunc-Prop A) -is-decidable-trunc-Prop-is-merely-decidable A = - map-universal-property-trunc-Prop - ( is-decidable-trunc-Prop A) - ( f) +module _ + {l1 l2 : Level} {P : UU l1} {Q : UU l2} where - f : is-decidable A → type-Prop (is-decidable-trunc-Prop A) - f (inl a) = inl (unit-trunc-Prop a) - f (inr f) = inr (map-universal-property-trunc-Prop empty-Prop f) - -is-merely-decidable-is-decidable-trunc-Prop : - {l : Level} (A : UU l) → - is-decidable (type-trunc-Prop A) → is-merely-decidable A -is-merely-decidable-is-decidable-trunc-Prop A (inl x) = - apply-universal-property-trunc-Prop x - ( is-merely-decidable-Prop A) - ( unit-trunc-Prop ∘ inl) -is-merely-decidable-is-decidable-trunc-Prop A (inr f) = - unit-trunc-Prop (inr (f ∘ unit-trunc-Prop)) + + is-decidable-prop-function-type' : + is-decidable P → (P → is-decidable-prop Q) → is-decidable-prop (P → Q) + is-decidable-prop-function-type' H K = + ( rec-coproduct + ( λ p → is-prop-function-type (is-prop-type-is-decidable-prop (K p))) + ( λ np → is-prop-is-contr (universal-property-empty-is-empty P np Q)) + ( H)) , + ( is-decidable-function-type' H (is-decidable-type-is-decidable-prop ∘ K)) + + is-decidable-prop-function-type : + is-decidable P → is-decidable-prop Q → is-decidable-prop (P → Q) + is-decidable-prop-function-type H K = + ( is-prop-function-type (is-prop-type-is-decidable-prop K)) , + ( is-decidable-function-type H (is-decidable-type-is-decidable-prop K)) + +hom-Decidable-Prop : + {l1 l2 : Level} → + Decidable-Prop l1 → Decidable-Prop l2 → Decidable-Prop (l1 ⊔ l2) +hom-Decidable-Prop P Q = + ( type-Decidable-Prop P → type-Decidable-Prop Q) , + ( is-decidable-prop-function-type + ( is-decidable-Decidable-Prop P) + ( is-decidable-prop-type-Decidable-Prop Q)) +``` + +### Dependent products of decidable propositions + +```agda +module _ + {l1 l2 : Level} {P : UU l1} {Q : P → UU l2} + where + + is-decidable-Π-is-decidable-prop : + is-decidable-prop P → + ((x : P) → is-decidable-prop (Q x)) → + is-decidable ((x : P) → Q x) + is-decidable-Π-is-decidable-prop (H , inl x) K = + rec-coproduct + ( λ y → inl (λ x' → tr Q (eq-is-prop H) y)) + ( λ ny → inr (λ f → ny (f x))) + ( is-decidable-type-is-decidable-prop (K x)) + is-decidable-Π-is-decidable-prop (H , inr nx) K = + inl (λ x' → ex-falso (nx x')) + + is-decidable-prop-Π : + is-decidable-prop P → + ((x : P) → is-decidable-prop (Q x)) → + is-decidable-prop ((x : P) → Q x) + is-decidable-prop-Π H K = + ( is-prop-Π (is-prop-type-is-decidable-prop ∘ K)) , + ( is-decidable-Π-is-decidable-prop H K) + +Π-Decidable-Prop : + {l1 l2 : Level} (P : Decidable-Prop l1) → + (type-Decidable-Prop P → Decidable-Prop l2) → Decidable-Prop (l1 ⊔ l2) +Π-Decidable-Prop P Q = + ( (x : type-Decidable-Prop P) → type-Decidable-Prop (Q x)) , + ( is-decidable-prop-Π + ( is-decidable-prop-type-Decidable-Prop P) + ( is-decidable-prop-type-Decidable-Prop ∘ Q)) ``` diff --git a/src/foundation-core/homotopies.lagda.md b/src/foundation-core/homotopies.lagda.md index 9ddfef0692..b507404937 100644 --- a/src/foundation-core/homotopies.lagda.md +++ b/src/foundation-core/homotopies.lagda.md @@ -347,8 +347,7 @@ module _ {H H' : f ~ g} where - ap-inv-htpy : - H ~ H' → inv-htpy H ~ inv-htpy H' + ap-inv-htpy : H ~ H' → inv-htpy H ~ inv-htpy H' ap-inv-htpy K x = ap inv (K x) ``` diff --git a/src/foundation-core/identity-types.lagda.md b/src/foundation-core/identity-types.lagda.md index 1a8a144f36..56b104ea96 100644 --- a/src/foundation-core/identity-types.lagda.md +++ b/src/foundation-core/identity-types.lagda.md @@ -120,10 +120,19 @@ have the induction principle of the identity type. ind-Id : {l1 l2 : Level} {A : UU l1} (x : A) (B : (y : A) (p : x ＝ y) → UU l2) → - (B x refl) → (y : A) (p : x ＝ y) → B y p + B x refl → (y : A) (p : x ＝ y) → B y p ind-Id x B b y refl = b ``` +### The recursion principle of identity types + +```agda +rec-Id : + {l1 l2 : Level} {A : UU l1} (x : A) {B : A → UU l2} → + B x → (y : A) → x ＝ y → B y +rec-Id x {B} = ind-Id x (λ y p → B y) +``` + ## Operations on the identity type The identity types form a weak groupoidal structure on types. Thus they come diff --git a/src/foundation-core/injective-maps.lagda.md b/src/foundation-core/injective-maps.lagda.md index 72003be269..86895ecbf7 100644 --- a/src/foundation-core/injective-maps.lagda.md +++ b/src/foundation-core/injective-maps.lagda.md @@ -18,6 +18,7 @@ open import foundation-core.function-types open import foundation-core.homotopies open import foundation-core.identity-types open import foundation-core.retractions +open import foundation-core.retracts-of-types open import foundation-core.sections ``` @@ -25,7 +26,9 @@ open import foundation-core.sections ## Idea -A map `f : A → B` is **injective** if `f x ＝ f y` implies `x ＝ y`. +A map `f : A → B` is +{{#concept "injective" Disambiguation="map of types" WD="injective function" WDID=Q12047217 Agda=is-injective Agda=injection}}, +also called _left cancellable_, if `f x ＝ f y` implies `x ＝ y`. ## Warning @@ -42,6 +45,16 @@ is-injective {l1} {l2} {A} {B} f = {x y : A} → f x ＝ f y → x ＝ y injection : {l1 l2 : Level} (A : UU l1) (B : UU l2) → UU (l1 ⊔ l2) injection A B = Σ (A → B) is-injective + +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} (f : injection A B) + where + + map-injection : A → B + map-injection = pr1 f + + is-injective-injection : is-injective map-injection + is-injective-injection = pr2 f ``` ## Examples @@ -100,6 +113,39 @@ module _ is-inj-h (is-inj-g ((inv (H x)) ∙ (p ∙ (H x')))) ``` +### Embeddings are injective + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-injective-is-emb : {f : A → B} → is-emb f → is-injective f + is-injective-is-emb is-emb-f {x} {y} = map-inv-is-equiv (is-emb-f x y) + + is-injective-emb : (e : A ↪ B) → is-injective (map-emb e) + is-injective-emb e {x} {y} = map-inv-is-equiv (is-emb-map-emb e x y) + + injection-emb : A ↪ B → injection A B + injection-emb (f , H) = (f , is-injective-is-emb H) +``` + +### Retracts are injective + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + is-injective-inclusion-retract : + (R : A retract-of B) → is-injective (inclusion-retract R) + is-injective-inclusion-retract (i , R) = is-injective-retraction i R + + injection-retract : A retract-of B → injection A B + injection-retract R = + ( inclusion-retract R , is-injective-inclusion-retract R) +``` + ### Equivalences are injective ```agda @@ -137,20 +183,6 @@ module _ is-equiv-is-invertible g G (λ x → H (G (f x))) ``` -### Any embedding is injective - -```agda -module _ - {l1 l2 : Level} {A : UU l1} {B : UU l2} - where - - is-injective-is-emb : {f : A → B} → is-emb f → is-injective f - is-injective-is-emb is-emb-f {x} {y} = map-inv-is-equiv (is-emb-f x y) - - is-injective-emb : (e : A ↪ B) → is-injective (map-emb e) - is-injective-emb e {x} {y} = map-inv-is-equiv (is-emb-map-emb e x y) -``` - ### Any map out of a contractible type is injective ```agda diff --git a/src/foundation-core/iterating-functions.lagda.md b/src/foundation-core/iterating-functions.lagda.md new file mode 100644 index 0000000000..e17b549215 --- /dev/null +++ b/src/foundation-core/iterating-functions.lagda.md @@ -0,0 +1,123 @@ +# Iterating functions + +```agda +module foundation-core.iterating-functions where +``` + +
Imports + +```agda +open import elementary-number-theory.natural-numbers + +open import foundation.action-on-identifications-functions +open import foundation.subtypes +open import foundation.universe-levels + +open import foundation-core.commuting-squares-of-maps +open import foundation-core.function-types +open import foundation-core.homotopies +open import foundation-core.identity-types +``` + +
+ +## Idea + +Any map `f : X → X` can be +{{#concept "iterated" Disambiguation="endo map of types" Agda=iterate Agda=iterate'}} +by repeatedly applying `f`. + +## Definition + +### Iterating functions + +```agda +module _ + {l : Level} {X : UU l} + where + + iterate : ℕ → (X → X) → (X → X) + iterate zero-ℕ f x = x + iterate (succ-ℕ k) f x = f (iterate k f x) + + iterate' : ℕ → (X → X) → (X → X) + iterate' zero-ℕ f x = x + iterate' (succ-ℕ k) f x = iterate' k f (f x) +``` + +### Homotopies of iterating functions + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} (s : A → A) (t : B → B) + where + + coherence-square-iterate : + {f : A → B} (H : coherence-square-maps f s t f) → + (n : ℕ) → coherence-square-maps f (iterate n s) (iterate n t) f + coherence-square-iterate {f} H zero-ℕ x = refl + coherence-square-iterate {f} H (succ-ℕ n) = + pasting-vertical-coherence-square-maps + ( f) + ( iterate n s) + ( iterate n t) + ( f) + ( s) + ( t) + ( f) + ( coherence-square-iterate H n) + ( H) +``` + +## Properties + +### The two definitions of iterating are homotopic + +```agda +module _ + {l : Level} {X : UU l} + where + + reassociate-iterate-succ-ℕ : + (k : ℕ) (f : X → X) (x : X) → iterate (succ-ℕ k) f x ＝ iterate k f (f x) + reassociate-iterate-succ-ℕ zero-ℕ f x = refl + reassociate-iterate-succ-ℕ (succ-ℕ k) f x = + ap f (reassociate-iterate-succ-ℕ k f x) + + reassociate-iterate : (k : ℕ) (f : X → X) → iterate k f ~ iterate' k f + reassociate-iterate zero-ℕ f x = refl + reassociate-iterate (succ-ℕ k) f x = + reassociate-iterate-succ-ℕ k f x ∙ reassociate-iterate k f (f x) +``` + +### If `f : X → X` satisfies a property of endofunctions on `X`, and the property is closed under composition then iterates of `f` satisfy the property + +```agda +module _ + {l1 l2 : Level} {X : UU l1} {f : X → X} + (P : subtype l2 (X → X)) + where + + is-in-subtype-iterate-succ-ℕ : + (F : is-in-subtype P f) → + ( (h g : X → X) → + is-in-subtype P h → + is-in-subtype P g → + is-in-subtype P (h ∘ g)) → + (n : ℕ) → is-in-subtype P (iterate (succ-ℕ n) f) + is-in-subtype-iterate-succ-ℕ F H zero-ℕ = F + is-in-subtype-iterate-succ-ℕ F H (succ-ℕ n) = + H f (iterate (succ-ℕ n) f) F (is-in-subtype-iterate-succ-ℕ F H n) + + is-in-subtype-iterate : + (I : is-in-subtype P (id {A = X})) → + (F : is-in-subtype P f) → + ( (h g : X → X) → + is-in-subtype P h → + is-in-subtype P g → + is-in-subtype P (h ∘ g)) → + (n : ℕ) → is-in-subtype P (iterate n f) + is-in-subtype-iterate I F H zero-ℕ = I + is-in-subtype-iterate I F H (succ-ℕ n) = + H f (iterate n f) F (is-in-subtype-iterate I F H n) +``` diff --git a/src/foundation-core/subtypes.lagda.md b/src/foundation-core/subtypes.lagda.md index 128f682668..5310ef728e 100644 --- a/src/foundation-core/subtypes.lagda.md +++ b/src/foundation-core/subtypes.lagda.md @@ -9,6 +9,7 @@ module foundation-core.subtypes where ```agda open import foundation.action-on-identifications-functions open import foundation.dependent-pair-types +open import foundation.injective-maps open import foundation.logical-equivalences open import foundation.subtype-identity-principle open import foundation.universe-levels @@ -192,6 +193,9 @@ module _ pr1 emb-subtype = inclusion-subtype B pr2 emb-subtype = is-emb-inclusion-subtype + injection-subtype : injection (type-subtype B) A + injection-subtype = injection-emb emb-subtype + equiv-ap-inclusion-subtype : {s t : type-subtype B} → (s ＝ t) ≃ (inclusion-subtype B s ＝ inclusion-subtype B t) diff --git a/src/foundation/decidable-dependent-function-types.lagda.md b/src/foundation/decidable-dependent-function-types.lagda.md index 48da0bfb77..3e97d92ffc 100644 --- a/src/foundation/decidable-dependent-function-types.lagda.md +++ b/src/foundation/decidable-dependent-function-types.lagda.md @@ -104,97 +104,6 @@ is-decidable-Π-Maybe {B = B} du de = ( is-decidable-product du de) ``` -### Dependent products of decidable propositions over a base with double negation dense equality are decidable propositions - -```agda -module _ - {l1 l2 : Level} {A : UU l1} (B : A → Decidable-Prop l2) - where - - is-decidable-Π-has-double-negation-dense-equality-base : - has-double-negation-dense-equality A → - is-decidable A → - is-decidable ((x : A) → type-Decidable-Prop (B x)) - is-decidable-Π-has-double-negation-dense-equality-base H dA = - is-decidable-Π-uniformly-decidable-family dA - ( is-uniformly-decidable-family-has-double-negation-dense-equality-base - ( H) - ( is-decidable-Decidable-Prop ∘ B) - ( dA)) - - is-decidable-prop-Π-has-double-negation-dense-equality-base : - has-double-negation-dense-equality A → - is-decidable A → - is-decidable-prop ((x : A) → type-Decidable-Prop (B x)) - is-decidable-prop-Π-has-double-negation-dense-equality-base H dA = - is-decidable-prop-Π-uniformly-decidable-family dA - ( is-uniformly-decidable-family-has-double-negation-dense-equality-base - ( H) - ( is-decidable-Decidable-Prop ∘ B) - ( dA)) - ( is-prop-type-Decidable-Prop ∘ B) - - is-decidable-prop-Π-has-double-negation-dense-equality-base' : - has-double-negation-dense-equality A → - is-inhabited-or-empty A → - is-decidable-prop ((x : A) → type-Decidable-Prop (B x)) - is-decidable-prop-Π-has-double-negation-dense-equality-base' H dA = - is-decidable-prop-Π-uniformly-decidable-family' dA - ( is-uniformly-decidable-family-has-double-negation-dense-equality-base' - ( H) - ( is-decidable-Decidable-Prop ∘ B) - ( dA) - ( is-prop-type-Decidable-Prop ∘ B)) - ( is-prop-type-Decidable-Prop ∘ B) -``` - -### Dependent products of decidable propositions over a base with mere equality are decidable propositions - -Assuming the base `A` is empty or 0-connected, a dependent product of decidable -propositions over `A` is again a decidable proposition. - -```agda -module _ - {l1 l2 : Level} {A : UU l1} (B : A → Decidable-Prop l2) - where - - is-decidable-Π-all-elements-merely-equal-base : - all-elements-merely-equal A → - is-decidable A → - is-decidable ((x : A) → type-Decidable-Prop (B x)) - is-decidable-Π-all-elements-merely-equal-base H dA = - is-decidable-Π-uniformly-decidable-family dA - ( is-uniformly-decidable-family-all-elements-merely-equal-base - ( H) - ( is-decidable-Decidable-Prop ∘ B) - ( dA)) - - is-decidable-prop-Π-all-elements-merely-equal-base : - all-elements-merely-equal A → - is-decidable A → - is-decidable-prop ((x : A) → type-Decidable-Prop (B x)) - is-decidable-prop-Π-all-elements-merely-equal-base H dA = - is-decidable-prop-Π-uniformly-decidable-family dA - ( is-uniformly-decidable-family-all-elements-merely-equal-base - ( H) - ( is-decidable-Decidable-Prop ∘ B) - ( dA)) - ( is-prop-type-Decidable-Prop ∘ B) - - is-decidable-prop-Π-all-elements-merely-equal-base' : - all-elements-merely-equal A → - is-inhabited-or-empty A → - is-decidable-prop ((x : A) → type-Decidable-Prop (B x)) - is-decidable-prop-Π-all-elements-merely-equal-base' H dA = - is-decidable-prop-Π-uniformly-decidable-family' dA - ( is-uniformly-decidable-family-all-elements-merely-equal-base' - ( H) - ( is-decidable-Decidable-Prop ∘ B) - ( dA) - ( is-prop-type-Decidable-Prop ∘ B)) - ( is-prop-type-Decidable-Prop ∘ B) -``` - ### Decidability of dependent products over an equivalence ```agda diff --git a/src/foundation/decidable-dependent-pair-types.lagda.md b/src/foundation/decidable-dependent-pair-types.lagda.md index 6d80fb78de..1fbf356676 100644 --- a/src/foundation/decidable-dependent-pair-types.lagda.md +++ b/src/foundation/decidable-dependent-pair-types.lagda.md @@ -94,30 +94,5 @@ is-decidable-Σ-Maybe {A = A} {B} dA de = ( is-decidable-equiv (left-unit-law-Σ (B ∘ inr)) de) ``` -### Decidability of dependent sums over bases with double negation dense equality - -```agda -module _ - {l1 l2 : Level} {A : UU l1} {B : A → UU l2} - (H : has-double-negation-dense-equality A) - where - - is-inhabited-or-empty-Σ-has-double-negation-dense-equality-base : - is-inhabited-or-empty A → - ((x : A) → is-inhabited-or-empty (B x)) → - is-inhabited-or-empty (Σ A B) - is-inhabited-or-empty-Σ-has-double-negation-dense-equality-base dA dB = - elim-is-inhabited-or-empty-Prop - ( is-inhabited-or-empty-Prop (Σ A B)) - ( λ a → - elim-is-inhabited-or-empty-Prop - ( is-inhabited-or-empty-Prop (Σ A B)) - ( λ b → inl (unit-trunc-Prop (a , b))) - ( λ nb → inr (λ x → H (pr1 x) a (λ p → nb (tr B p (pr2 x))))) - ( dB a)) - ( λ na → inr (map-neg pr1 na)) - ( dA) -``` - See [`foundation.decidable-types`](foundation.decidable-types.md) for the untruncated version. diff --git a/src/foundation/decidable-types.lagda.md b/src/foundation/decidable-types.lagda.md index 4ab1a9b661..d2c92a2182 100644 --- a/src/foundation/decidable-types.lagda.md +++ b/src/foundation/decidable-types.lagda.md @@ -16,7 +16,6 @@ open import foundation.equivalences open import foundation.evaluation-functions open import foundation.functoriality-coproduct-types open import foundation.hilberts-epsilon-operators -open import foundation.irrefutable-equality open import foundation.logical-equivalences open import foundation.negation open import foundation.propositional-truncations @@ -294,23 +293,6 @@ is-fixed-point-is-decidable-is-inhabited {l} {X} t = right-unit-law-coproduct-is-empty X (¬ X) (is-nonempty-is-inhabited t) ``` -### The dependent sum of a family of decidable propositions over a decidable base with double negation dense equality is decidable - -```agda -is-decidable-Σ-has-double-negation-dense-equality-base : - {l1 l2 : Level} {P : UU l1} {Q : P → UU l2} → - has-double-negation-dense-equality P → - is-decidable P → - ((x : P) → is-decidable (Q x)) → is-decidable (Σ P Q) -is-decidable-Σ-has-double-negation-dense-equality-base {Q = Q} hP (inl p) dQ = - map-coproduct - ( pair p) - ( λ nq pq → hP (pr1 pq) p (λ r → nq (tr Q r (pr2 pq)))) - ( dQ p) -is-decidable-Σ-has-double-negation-dense-equality-base hP (inr np) _ = - inr (map-neg pr1 np) -``` - ### Raising universe level conserves decidability ```agda From e5c32a4b1d9817a7a4ec243f9edb617868aeeac6 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Fri, 28 Mar 2025 16:44:20 +0000 Subject: [PATCH 03/20] fix by adding _some_ equality stuff --- .../iterating-functions.lagda.md | 123 ------------- src/foundation.lagda.md | 1 + src/foundation/booleans.lagda.md | 6 - ...ecidable-dependent-function-types.lagda.md | 47 +++++ .../decidable-dependent-pair-types.lagda.md | 25 +++ src/foundation/decidable-types.lagda.md | 18 ++ src/foundation/irrefutable-equality.lagda.md | 162 ++++++++++++++++++ src/foundation/mere-equality.lagda.md | 81 ++++++++- 8 files changed, 327 insertions(+), 136 deletions(-) delete mode 100644 src/foundation-core/iterating-functions.lagda.md create mode 100644 src/foundation/irrefutable-equality.lagda.md diff --git a/src/foundation-core/iterating-functions.lagda.md b/src/foundation-core/iterating-functions.lagda.md deleted file mode 100644 index e17b549215..0000000000 --- a/src/foundation-core/iterating-functions.lagda.md +++ /dev/null @@ -1,123 +0,0 @@ -# Iterating functions - -```agda -module foundation-core.iterating-functions where -``` - -
Imports - -```agda -open import elementary-number-theory.natural-numbers - -open import foundation.action-on-identifications-functions -open import foundation.subtypes -open import foundation.universe-levels - -open import foundation-core.commuting-squares-of-maps -open import foundation-core.function-types -open import foundation-core.homotopies -open import foundation-core.identity-types -``` - -
- -## Idea - -Any map `f : X → X` can be -{{#concept "iterated" Disambiguation="endo map of types" Agda=iterate Agda=iterate'}} -by repeatedly applying `f`. - -## Definition - -### Iterating functions - -```agda -module _ - {l : Level} {X : UU l} - where - - iterate : ℕ → (X → X) → (X → X) - iterate zero-ℕ f x = x - iterate (succ-ℕ k) f x = f (iterate k f x) - - iterate' : ℕ → (X → X) → (X → X) - iterate' zero-ℕ f x = x - iterate' (succ-ℕ k) f x = iterate' k f (f x) -``` - -### Homotopies of iterating functions - -```agda -module _ - {l1 l2 : Level} {A : UU l1} {B : UU l2} (s : A → A) (t : B → B) - where - - coherence-square-iterate : - {f : A → B} (H : coherence-square-maps f s t f) → - (n : ℕ) → coherence-square-maps f (iterate n s) (iterate n t) f - coherence-square-iterate {f} H zero-ℕ x = refl - coherence-square-iterate {f} H (succ-ℕ n) = - pasting-vertical-coherence-square-maps - ( f) - ( iterate n s) - ( iterate n t) - ( f) - ( s) - ( t) - ( f) - ( coherence-square-iterate H n) - ( H) -``` - -## Properties - -### The two definitions of iterating are homotopic - -```agda -module _ - {l : Level} {X : UU l} - where - - reassociate-iterate-succ-ℕ : - (k : ℕ) (f : X → X) (x : X) → iterate (succ-ℕ k) f x ＝ iterate k f (f x) - reassociate-iterate-succ-ℕ zero-ℕ f x = refl - reassociate-iterate-succ-ℕ (succ-ℕ k) f x = - ap f (reassociate-iterate-succ-ℕ k f x) - - reassociate-iterate : (k : ℕ) (f : X → X) → iterate k f ~ iterate' k f - reassociate-iterate zero-ℕ f x = refl - reassociate-iterate (succ-ℕ k) f x = - reassociate-iterate-succ-ℕ k f x ∙ reassociate-iterate k f (f x) -``` - -### If `f : X → X` satisfies a property of endofunctions on `X`, and the property is closed under composition then iterates of `f` satisfy the property - -```agda -module _ - {l1 l2 : Level} {X : UU l1} {f : X → X} - (P : subtype l2 (X → X)) - where - - is-in-subtype-iterate-succ-ℕ : - (F : is-in-subtype P f) → - ( (h g : X → X) → - is-in-subtype P h → - is-in-subtype P g → - is-in-subtype P (h ∘ g)) → - (n : ℕ) → is-in-subtype P (iterate (succ-ℕ n) f) - is-in-subtype-iterate-succ-ℕ F H zero-ℕ = F - is-in-subtype-iterate-succ-ℕ F H (succ-ℕ n) = - H f (iterate (succ-ℕ n) f) F (is-in-subtype-iterate-succ-ℕ F H n) - - is-in-subtype-iterate : - (I : is-in-subtype P (id {A = X})) → - (F : is-in-subtype P f) → - ( (h g : X → X) → - is-in-subtype P h → - is-in-subtype P g → - is-in-subtype P (h ∘ g)) → - (n : ℕ) → is-in-subtype P (iterate n f) - is-in-subtype-iterate I F H zero-ℕ = I - is-in-subtype-iterate I F H (succ-ℕ n) = - H f (iterate n f) F (is-in-subtype-iterate I F H n) -``` diff --git a/src/foundation.lagda.md b/src/foundation.lagda.md index abfcf94775..ac62b0327f 100644 --- a/src/foundation.lagda.md +++ b/src/foundation.lagda.md @@ -254,6 +254,7 @@ open import foundation.intersections-subtypes public open import foundation.inverse-sequential-diagrams public open import foundation.invertible-maps public open import foundation.involutions public +open import foundation.irrefutable-equality public open import foundation.irrefutable-propositions public open import foundation.isolated-elements public open import foundation.isomorphisms-of-sets public diff --git a/src/foundation/booleans.lagda.md b/src/foundation/booleans.lagda.md index efa937da3b..b1e7d99e32 100644 --- a/src/foundation/booleans.lagda.md +++ b/src/foundation/booleans.lagda.md @@ -22,7 +22,6 @@ open import foundation.universe-levels open import foundation-core.constant-maps open import foundation-core.coproduct-types open import foundation-core.decidable-propositions -open import foundation-core.double-negation-stable-equality open import foundation-core.empty-types open import foundation-core.equivalences open import foundation-core.function-types @@ -200,11 +199,6 @@ has-decidable-equality-bool false false = inl refl bool-Discrete-Type : Discrete-Type lzero bool-Discrete-Type = bool , has-decidable-equality-bool - -has-double-negation-stable-equality-bool : - has-double-negation-stable-equality bool -has-double-negation-stable-equality-bool x y = - double-negation-elim-is-decidable (has-decidable-equality-bool x y) ``` ### The booleans have a tight apartness relation diff --git a/src/foundation/decidable-dependent-function-types.lagda.md b/src/foundation/decidable-dependent-function-types.lagda.md index 3e97d92ffc..d97239bda0 100644 --- a/src/foundation/decidable-dependent-function-types.lagda.md +++ b/src/foundation/decidable-dependent-function-types.lagda.md @@ -104,6 +104,53 @@ is-decidable-Π-Maybe {B = B} du de = ( is-decidable-product du de) ``` +### Dependent products of decidable propositions over a base with mere equality are decidable propositions + +Assuming the base `A` is empty or 0-connected, a dependent product of decidable +propositions over `A` is again a decidable proposition. + +```agda +module _ + {l1 l2 : Level} {A : UU l1} (B : A → Decidable-Prop l2) + where + + is-decidable-Π-all-elements-merely-equal-base : + all-elements-merely-equal A → + is-decidable A → + is-decidable ((x : A) → type-Decidable-Prop (B x)) + is-decidable-Π-all-elements-merely-equal-base H dA = + is-decidable-Π-uniformly-decidable-family dA + ( is-uniformly-decidable-family-all-elements-merely-equal-base + ( H) + ( is-decidable-Decidable-Prop ∘ B) + ( dA)) + + is-decidable-prop-Π-all-elements-merely-equal-base : + all-elements-merely-equal A → + is-decidable A → + is-decidable-prop ((x : A) → type-Decidable-Prop (B x)) + is-decidable-prop-Π-all-elements-merely-equal-base H dA = + is-decidable-prop-Π-uniformly-decidable-family dA + ( is-uniformly-decidable-family-all-elements-merely-equal-base + ( H) + ( is-decidable-Decidable-Prop ∘ B) + ( dA)) + ( is-prop-type-Decidable-Prop ∘ B) + + is-decidable-prop-Π-all-elements-merely-equal-base' : + all-elements-merely-equal A → + is-inhabited-or-empty A → + is-decidable-prop ((x : A) → type-Decidable-Prop (B x)) + is-decidable-prop-Π-all-elements-merely-equal-base' H dA = + is-decidable-prop-Π-uniformly-decidable-family' dA + ( is-uniformly-decidable-family-all-elements-merely-equal-base' + ( H) + ( is-decidable-Decidable-Prop ∘ B) + ( dA) + ( is-prop-type-Decidable-Prop ∘ B)) + ( is-prop-type-Decidable-Prop ∘ B) +``` + ### Decidability of dependent products over an equivalence ```agda diff --git a/src/foundation/decidable-dependent-pair-types.lagda.md b/src/foundation/decidable-dependent-pair-types.lagda.md index 1fbf356676..6d80fb78de 100644 --- a/src/foundation/decidable-dependent-pair-types.lagda.md +++ b/src/foundation/decidable-dependent-pair-types.lagda.md @@ -94,5 +94,30 @@ is-decidable-Σ-Maybe {A = A} {B} dA de = ( is-decidable-equiv (left-unit-law-Σ (B ∘ inr)) de) ``` +### Decidability of dependent sums over bases with double negation dense equality + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} + (H : has-double-negation-dense-equality A) + where + + is-inhabited-or-empty-Σ-has-double-negation-dense-equality-base : + is-inhabited-or-empty A → + ((x : A) → is-inhabited-or-empty (B x)) → + is-inhabited-or-empty (Σ A B) + is-inhabited-or-empty-Σ-has-double-negation-dense-equality-base dA dB = + elim-is-inhabited-or-empty-Prop + ( is-inhabited-or-empty-Prop (Σ A B)) + ( λ a → + elim-is-inhabited-or-empty-Prop + ( is-inhabited-or-empty-Prop (Σ A B)) + ( λ b → inl (unit-trunc-Prop (a , b))) + ( λ nb → inr (λ x → H (pr1 x) a (λ p → nb (tr B p (pr2 x))))) + ( dB a)) + ( λ na → inr (map-neg pr1 na)) + ( dA) +``` + See [`foundation.decidable-types`](foundation.decidable-types.md) for the untruncated version. diff --git a/src/foundation/decidable-types.lagda.md b/src/foundation/decidable-types.lagda.md index d2c92a2182..4ab1a9b661 100644 --- a/src/foundation/decidable-types.lagda.md +++ b/src/foundation/decidable-types.lagda.md @@ -16,6 +16,7 @@ open import foundation.equivalences open import foundation.evaluation-functions open import foundation.functoriality-coproduct-types open import foundation.hilberts-epsilon-operators +open import foundation.irrefutable-equality open import foundation.logical-equivalences open import foundation.negation open import foundation.propositional-truncations @@ -293,6 +294,23 @@ is-fixed-point-is-decidable-is-inhabited {l} {X} t = right-unit-law-coproduct-is-empty X (¬ X) (is-nonempty-is-inhabited t) ``` +### The dependent sum of a family of decidable propositions over a decidable base with double negation dense equality is decidable + +```agda +is-decidable-Σ-has-double-negation-dense-equality-base : + {l1 l2 : Level} {P : UU l1} {Q : P → UU l2} → + has-double-negation-dense-equality P → + is-decidable P → + ((x : P) → is-decidable (Q x)) → is-decidable (Σ P Q) +is-decidable-Σ-has-double-negation-dense-equality-base {Q = Q} hP (inl p) dQ = + map-coproduct + ( pair p) + ( λ nq pq → hP (pr1 pq) p (λ r → nq (tr Q r (pr2 pq)))) + ( dQ p) +is-decidable-Σ-has-double-negation-dense-equality-base hP (inr np) _ = + inr (map-neg pr1 np) +``` + ### Raising universe level conserves decidability ```agda diff --git a/src/foundation/irrefutable-equality.lagda.md b/src/foundation/irrefutable-equality.lagda.md new file mode 100644 index 0000000000..cfe37e3665 --- /dev/null +++ b/src/foundation/irrefutable-equality.lagda.md @@ -0,0 +1,162 @@ +# Irrefutable equality + +```agda +module foundation.irrefutable-equality where +``` + +
Imports + +```agda +open import foundation.action-on-identifications-functions +open import foundation.binary-relations +open import foundation.dependent-pair-types +open import foundation.double-negation +open import foundation.equality-dependent-pair-types +open import foundation.equivalences +open import foundation.retracts-of-types +open import foundation.transport-along-identifications +open import foundation.universe-levels + +open import foundation-core.equivalence-relations +open import foundation-core.identity-types +open import foundation-core.propositions +open import foundation-core.sets +``` + +
+ +## Idea + +Two elements `x` and `y` in a type are said to be +{{#concept "irrefutably equal" Disambiguation="elements of a type" Agda=irrefutable-eq}} +if there is an element of the [double negation](foundation.double-negation.md) +of the [identity type](foundation-core.identity-types.md) between them, +`¬¬ (x ＝ y)`. If every two elements of a type are irrefutably equal, we say the +type _has double negation dense equality_. + +## Definitions + +### Irrefutably equal elements + +```agda +module _ + {l : Level} {A : UU l} + where + + irrefutable-eq : A → A → UU l + irrefutable-eq x y = ¬¬ (x ＝ y) + + is-prop-irrefutable-eq : (x y : A) → is-prop (irrefutable-eq x y) + is-prop-irrefutable-eq x y = is-prop-double-negation + + irrefutable-eq-Prop : A → A → Prop l + irrefutable-eq-Prop x y = (irrefutable-eq x y , is-prop-irrefutable-eq x y) +``` + +### Types with double negation dense equality + +```agda +has-double-negation-dense-equality : {l : Level} → UU l → UU l +has-double-negation-dense-equality A = (x y : A) → irrefutable-eq x y +``` + +## Properties + +### Reflexivity + +```agda +abstract + refl-irrefutable-eq : + {l : Level} {A : UU l} → is-reflexive (irrefutable-eq {l} {A}) + refl-irrefutable-eq _ = intro-double-negation refl + +irrefutable-eq-eq : + {l : Level} {A : UU l} {x y : A} → x ＝ y → irrefutable-eq x y +irrefutable-eq-eq = intro-double-negation +``` + +### Symmetry + +```agda +abstract + symmetric-irrefutable-eq : + {l : Level} {A : UU l} → is-symmetric (irrefutable-eq {l} {A}) + symmetric-irrefutable-eq _ _ = map-double-negation inv +``` + +### Transitivity + +```agda +abstract + transitive-irrefutable-eq : + {l : Level} {A : UU l} → is-transitive (irrefutable-eq {l} {A}) + transitive-irrefutable-eq x y z nnp nnq npq = + nnp (λ p → nnq (λ q → npq (q ∙ p))) +``` + +### Irrefutable equality is an equivalence relation + +```agda +irrefutable-eq-equivalence-relation : + {l1 : Level} (A : UU l1) → equivalence-relation l1 A +pr1 (irrefutable-eq-equivalence-relation A) = irrefutable-eq-Prop +pr1 (pr2 (irrefutable-eq-equivalence-relation A)) = refl-irrefutable-eq +pr1 (pr2 (pr2 (irrefutable-eq-equivalence-relation A))) = + symmetric-irrefutable-eq +pr2 (pr2 (pr2 (irrefutable-eq-equivalence-relation A))) = + transitive-irrefutable-eq +``` + +### If irrefutable equality maps into the identity type of `A`, then `A` is a set + +```agda +is-set-irrefutable-eq-in-id : + {l : Level} {A : UU l} → ((x y : A) → irrefutable-eq x y → x ＝ y) → is-set A +is-set-irrefutable-eq-in-id = + is-set-prop-in-id irrefutable-eq is-prop-irrefutable-eq refl-irrefutable-eq +``` + +### Retracts of types with double negation dense equality + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + has-double-negation-dense-equality-retract-of : + B retract-of A → + has-double-negation-dense-equality A → + has-double-negation-dense-equality B + has-double-negation-dense-equality-retract-of (i , r , R) H x y = + map-double-negation (λ p → inv (R x) ∙ ap r p ∙ R y) (H (i x) (i y)) + + has-double-negation-dense-equality-equiv : + B ≃ A → + has-double-negation-dense-equality A → has-double-negation-dense-equality B + has-double-negation-dense-equality-equiv e = + has-double-negation-dense-equality-retract-of (retract-equiv e) + + has-double-negation-dense-equality-equiv' : + A ≃ B → + has-double-negation-dense-equality A → has-double-negation-dense-equality B + has-double-negation-dense-equality-equiv' e = + has-double-negation-dense-equality-retract-of (retract-inv-equiv e) +``` + +### Dependent sums of types with double negation dense equality + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} + (mA : has-double-negation-dense-equality A) + (mB : (x : A) → has-double-negation-dense-equality (B x)) + where + + has-double-negation-dense-equality-Σ : + has-double-negation-dense-equality (Σ A B) + has-double-negation-dense-equality-Σ x y = + extend-double-negation + ( λ p → + map-double-negation (eq-pair-Σ p) (mB (pr1 y) (tr B p (pr2 x)) (pr2 y))) + ( mA (pr1 x) (pr1 y)) +``` diff --git a/src/foundation/mere-equality.lagda.md b/src/foundation/mere-equality.lagda.md index d5319cae0a..39d7049b9b 100644 --- a/src/foundation/mere-equality.lagda.md +++ b/src/foundation/mere-equality.lagda.md @@ -10,9 +10,15 @@ module foundation.mere-equality where open import foundation.action-on-identifications-functions open import foundation.binary-relations open import foundation.dependent-pair-types +open import foundation.double-negation +open import foundation.equality-dependent-pair-types +open import foundation.equivalences open import foundation.functoriality-propositional-truncation +open import foundation.irrefutable-equality open import foundation.propositional-truncations open import foundation.reflecting-maps-equivalence-relations +open import foundation.retracts-of-types +open import foundation.transport-along-identifications open import foundation.universe-levels open import foundation-core.equivalence-relations @@ -28,7 +34,7 @@ open import foundation-core.sets Two elements in a type are said to be merely equal if there is an element of the propositionally truncated identity type between them. -## Definition +## Definitions ```agda module _ @@ -45,6 +51,13 @@ module _ is-prop-mere-eq x y = is-prop-type-trunc-Prop ``` +### Types whose elements are merely equal + +```agda +all-elements-merely-equal : {l : Level} → UU l → UU l +all-elements-merely-equal A = (x y : A) → mere-eq x y +``` + ## Properties ### Reflexivity @@ -107,8 +120,7 @@ module _ reflecting-map-equivalence-relation ( mere-eq-equivalence-relation A) ( type-Set X) - pr1 reflecting-map-mere-eq = f - pr2 reflecting-map-mere-eq = reflects-mere-eq + reflecting-map-mere-eq = (f , reflects-mere-eq) ``` ### If mere equality maps into the identity type of `A`, then `A` is a set @@ -117,8 +129,63 @@ module _ is-set-mere-eq-in-id : {l : Level} {A : UU l} → ((x y : A) → mere-eq x y → x ＝ y) → is-set A is-set-mere-eq-in-id = - is-set-prop-in-id - ( mere-eq) - ( is-prop-mere-eq) - ( refl-mere-eq) + is-set-prop-in-id mere-eq is-prop-mere-eq refl-mere-eq +``` + +In other words, if equality on `A` has an +[ε-operator](foundation.hilberts-epsilon-operators.md), then `A` is a set. + +### Retracts of types with merely equal elements + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + all-elements-merely-equal-retract-of : + B retract-of A → all-elements-merely-equal A → all-elements-merely-equal B + all-elements-merely-equal-retract-of (i , r , R) H x y = + rec-trunc-Prop + ( mere-eq-Prop x y) + ( λ p → unit-trunc-Prop (inv (R x) ∙ ap r p ∙ R y)) + ( H (i x) (i y)) + + all-elements-merely-equal-equiv : + B ≃ A → all-elements-merely-equal A → all-elements-merely-equal B + all-elements-merely-equal-equiv e = + all-elements-merely-equal-retract-of (retract-equiv e) + + all-elements-merely-equal-equiv' : + A ≃ B → all-elements-merely-equal A → all-elements-merely-equal B + all-elements-merely-equal-equiv' e = + all-elements-merely-equal-retract-of (retract-inv-equiv e) +``` + +### Dependent sums of types with merely equal elements + +```agda +all-elements-merely-equal-Σ : + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} → + all-elements-merely-equal A → + ((x : A) → all-elements-merely-equal (B x)) → + all-elements-merely-equal (Σ A B) +all-elements-merely-equal-Σ {B = B} mA mB x y = + rec-trunc-Prop + ( mere-eq-Prop x y) + ( λ p → map-trunc-Prop (eq-pair-Σ p) (mB (pr1 y) (tr B p (pr2 x)) (pr2 y))) + ( mA (pr1 x) (pr1 y)) +``` + +### Mere equality implies irrefutable equality + +```agda +irrefutable-eq-mere-eq : + {l : Level} {A : UU l} {x y : A} → mere-eq x y → irrefutable-eq x y +irrefutable-eq-mere-eq = intro-double-negation-type-trunc-Prop + +has-double-negation-dense-equality-all-elements-merely-equal : + {l : Level} {A : UU l} → + all-elements-merely-equal A → has-double-negation-dense-equality A +has-double-negation-dense-equality-all-elements-merely-equal H x y = + irrefutable-eq-mere-eq (H x y) ``` From c2d3a443e28b1bfcb6184ac203041a5a27c69868 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Fri, 28 Mar 2025 16:45:37 +0000 Subject: [PATCH 04/20] pre-commit --- src/foundation-core.lagda.md | 1 - 1 file changed, 1 deletion(-) diff --git a/src/foundation-core.lagda.md b/src/foundation-core.lagda.md index ea01876a8c..9b9dd2512c 100644 --- a/src/foundation-core.lagda.md +++ b/src/foundation-core.lagda.md @@ -36,7 +36,6 @@ open import foundation-core.homotopies public open import foundation-core.identity-types public open import foundation-core.injective-maps public open import foundation-core.invertible-maps public -open import foundation-core.iterating-functions public open import foundation-core.negation public open import foundation-core.operations-span-diagrams public open import foundation-core.operations-spans public From 7caebbcc0f606f33e19210b0a19d5eaf283e22a7 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Fri, 28 Mar 2025 16:48:36 +0000 Subject: [PATCH 05/20] fix `literature.intro-hott` --- ...roduction-to-homotopy-type-theory.lagda.md | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/literature/introduction-to-homotopy-type-theory.lagda.md b/src/literature/introduction-to-homotopy-type-theory.lagda.md index 73694d20ac..c849718839 100644 --- a/src/literature/introduction-to-homotopy-type-theory.lagda.md +++ b/src/literature/introduction-to-homotopy-type-theory.lagda.md @@ -302,16 +302,16 @@ open import foundation.booleans using ; ind-bool) -- (a) -open import foundation.booleans using +open import foundation.logical-operations-booleans using ( neg-bool) -- (b) -open import foundation.booleans using - ( conjunction-bool) +open import foundation.logical-operations-booleans using + ( and-bool) -- (c) -open import foundation.booleans using - ( disjunction-bool) +open import foundation.logical-operations-booleans using + ( or-bool) ``` **Exercise 4.3.** Double negation. @@ -336,7 +336,7 @@ open import foundation.double-negation using ( ¬¬_ ; intro-double-negation -- P → ¬¬P ; map-double-negation -- (P → Q) → (¬¬P → ¬¬Q) - ; double-negation-extend -- (P → ¬¬Q) → (¬¬P → ¬¬Q) + ; extend-double-negation -- (P → ¬¬Q) → (¬¬P → ¬¬Q) ) -- (c) @@ -345,7 +345,7 @@ open import foundation.double-negation using ; double-negation-Peirces-law -- ¬¬(((P → Q) → P) → P) ; double-negation-linearity-implication -- ¬¬((P → Q) + (Q → P)) ) -open import foundation.irrefutable-propositions using +open import logic.irrefutable-types using ( is-irrefutable-is-decidable -- ¬¬(P + ¬P) ) @@ -382,7 +382,7 @@ _ = ( double-negation-elim-neg (¬ Q)) -- (f) -open import foundation.irrefutable-propositions using +open import logic.irrefutable-types using ( is-irrefutable-product -- ¬¬A → ¬¬B → ¬¬(A × B) ) @@ -935,7 +935,7 @@ _ : (x y : bool) → (x ＝ y) ↔ Eq-bool x y _ = λ x y → (Eq-eq-bool , eq-Eq-bool) -- (c) -open import foundation.booleans using +open import foundation.logical-operations-booleans using ( neq-neg-bool -- b ≠ neg-bool b ) _ : ¬ (false ＝ true) @@ -1753,7 +1753,7 @@ open import elementary-number-theory.collatz-conjecture using ```agda open import foundation.decidable-types using - ( idempotent-is-decidable -- is-decidable (is-decidable P) → is-decidable P + ( map-idempotent-is-decidable -- is-decidable (is-decidable P) → is-decidable P ) ``` From 0837057d8d223e94e089a2871c9f3266d49f7f93 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Fri, 28 Mar 2025 17:20:02 +0000 Subject: [PATCH 06/20] fix --- .../iterating-functions.lagda.md | 123 ++++++++++++++++++ .../decidable-dependent-pair-types.lagda.md | 4 + src/foundation/decidable-types.lagda.md | 4 + src/foundation/iterating-functions.lagda.md | 69 +--------- .../cantors-diagonal-argument.lagda.md | 2 + 5 files changed, 138 insertions(+), 64 deletions(-) create mode 100644 src/foundation-core/iterating-functions.lagda.md diff --git a/src/foundation-core/iterating-functions.lagda.md b/src/foundation-core/iterating-functions.lagda.md new file mode 100644 index 0000000000..e17b549215 --- /dev/null +++ b/src/foundation-core/iterating-functions.lagda.md @@ -0,0 +1,123 @@ +# Iterating functions + +```agda +module foundation-core.iterating-functions where +``` + +
Imports + +```agda +open import elementary-number-theory.natural-numbers + +open import foundation.action-on-identifications-functions +open import foundation.subtypes +open import foundation.universe-levels + +open import foundation-core.commuting-squares-of-maps +open import foundation-core.function-types +open import foundation-core.homotopies +open import foundation-core.identity-types +``` + +
+ +## Idea + +Any map `f : X → X` can be +{{#concept "iterated" Disambiguation="endo map of types" Agda=iterate Agda=iterate'}} +by repeatedly applying `f`. + +## Definition + +### Iterating functions + +```agda +module _ + {l : Level} {X : UU l} + where + + iterate : ℕ → (X → X) → (X → X) + iterate zero-ℕ f x = x + iterate (succ-ℕ k) f x = f (iterate k f x) + + iterate' : ℕ → (X → X) → (X → X) + iterate' zero-ℕ f x = x + iterate' (succ-ℕ k) f x = iterate' k f (f x) +``` + +### Homotopies of iterating functions + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} (s : A → A) (t : B → B) + where + + coherence-square-iterate : + {f : A → B} (H : coherence-square-maps f s t f) → + (n : ℕ) → coherence-square-maps f (iterate n s) (iterate n t) f + coherence-square-iterate {f} H zero-ℕ x = refl + coherence-square-iterate {f} H (succ-ℕ n) = + pasting-vertical-coherence-square-maps + ( f) + ( iterate n s) + ( iterate n t) + ( f) + ( s) + ( t) + ( f) + ( coherence-square-iterate H n) + ( H) +``` + +## Properties + +### The two definitions of iterating are homotopic + +```agda +module _ + {l : Level} {X : UU l} + where + + reassociate-iterate-succ-ℕ : + (k : ℕ) (f : X → X) (x : X) → iterate (succ-ℕ k) f x ＝ iterate k f (f x) + reassociate-iterate-succ-ℕ zero-ℕ f x = refl + reassociate-iterate-succ-ℕ (succ-ℕ k) f x = + ap f (reassociate-iterate-succ-ℕ k f x) + + reassociate-iterate : (k : ℕ) (f : X → X) → iterate k f ~ iterate' k f + reassociate-iterate zero-ℕ f x = refl + reassociate-iterate (succ-ℕ k) f x = + reassociate-iterate-succ-ℕ k f x ∙ reassociate-iterate k f (f x) +``` + +### If `f : X → X` satisfies a property of endofunctions on `X`, and the property is closed under composition then iterates of `f` satisfy the property + +```agda +module _ + {l1 l2 : Level} {X : UU l1} {f : X → X} + (P : subtype l2 (X → X)) + where + + is-in-subtype-iterate-succ-ℕ : + (F : is-in-subtype P f) → + ( (h g : X → X) → + is-in-subtype P h → + is-in-subtype P g → + is-in-subtype P (h ∘ g)) → + (n : ℕ) → is-in-subtype P (iterate (succ-ℕ n) f) + is-in-subtype-iterate-succ-ℕ F H zero-ℕ = F + is-in-subtype-iterate-succ-ℕ F H (succ-ℕ n) = + H f (iterate (succ-ℕ n) f) F (is-in-subtype-iterate-succ-ℕ F H n) + + is-in-subtype-iterate : + (I : is-in-subtype P (id {A = X})) → + (F : is-in-subtype P f) → + ( (h g : X → X) → + is-in-subtype P h → + is-in-subtype P g → + is-in-subtype P (h ∘ g)) → + (n : ℕ) → is-in-subtype P (iterate n f) + is-in-subtype-iterate I F H zero-ℕ = I + is-in-subtype-iterate I F H (succ-ℕ n) = + H f (iterate n f) F (is-in-subtype-iterate I F H n) +``` diff --git a/src/foundation/decidable-dependent-pair-types.lagda.md b/src/foundation/decidable-dependent-pair-types.lagda.md index 6d80fb78de..54dc95399b 100644 --- a/src/foundation/decidable-dependent-pair-types.lagda.md +++ b/src/foundation/decidable-dependent-pair-types.lagda.md @@ -96,6 +96,10 @@ is-decidable-Σ-Maybe {A = A} {B} dA de = ### Decidability of dependent sums over bases with double negation dense equality +This is a special case of the more general fact that a type has decidable sums +if and only if its totally separated reflection does, and totally separated +types have double negation stable equality. {{#cite TypeTopology}} + ```agda module _ {l1 l2 : Level} {A : UU l1} {B : A → UU l2} diff --git a/src/foundation/decidable-types.lagda.md b/src/foundation/decidable-types.lagda.md index 4ab1a9b661..f23da39218 100644 --- a/src/foundation/decidable-types.lagda.md +++ b/src/foundation/decidable-types.lagda.md @@ -296,6 +296,10 @@ is-fixed-point-is-decidable-is-inhabited {l} {X} t = ### The dependent sum of a family of decidable propositions over a decidable base with double negation dense equality is decidable +This is a special case of the more general fact that a type has decidable sums +if and only if its totally separated reflection does, and totally separated +types have double negation stable equality. {{#cite TypeTopology}} + ```agda is-decidable-Σ-has-double-negation-dense-equality-base : {l1 l2 : Level} {P : UU l1} {Q : P → UU l2} → diff --git a/src/foundation/iterating-functions.lagda.md b/src/foundation/iterating-functions.lagda.md index 60dafe2242..97c6d29d93 100644 --- a/src/foundation/iterating-functions.lagda.md +++ b/src/foundation/iterating-functions.lagda.md @@ -2,6 +2,8 @@ ```agda module foundation.iterating-functions where + +open import foundation-core.iterating-functions public ```
Imports @@ -19,9 +21,7 @@ open import foundation.dependent-pair-types open import foundation.function-extensionality open import foundation.universe-levels -open import foundation-core.commuting-squares-of-maps open import foundation-core.endomorphisms -open import foundation-core.homotopies open import foundation-core.identity-types open import foundation-core.sets @@ -32,71 +32,12 @@ open import group-theory.monoid-actions ## Idea -Any map `f : X → X` can be iterated by repeatedly applying `f` - -## Definition - -### Iterating functions - -```agda -module _ - {l : Level} {X : UU l} - where - - iterate : ℕ → (X → X) → (X → X) - iterate zero-ℕ f x = x - iterate (succ-ℕ k) f x = f (iterate k f x) - - iterate' : ℕ → (X → X) → (X → X) - iterate' zero-ℕ f x = x - iterate' (succ-ℕ k) f x = iterate' k f (f x) -``` - -### Homotopies of iterating functions - -```agda -module _ - {l1 l2 : Level} {A : UU l1} {B : UU l2} (s : A → A) (t : B → B) - where - - coherence-square-iterate : - {f : A → B} (H : coherence-square-maps f s t f) → - (n : ℕ) → coherence-square-maps f (iterate n s) (iterate n t) f - coherence-square-iterate {f} H zero-ℕ x = refl - coherence-square-iterate {f} H (succ-ℕ n) = - pasting-vertical-coherence-square-maps - ( f) - ( iterate n s) - ( iterate n t) - ( f) - ( s) - ( t) - ( f) - ( coherence-square-iterate H n) - ( H) -``` +Any map `f : X → X` can be +{{#concept "iterated" Disambiguation="endo map of types"}} by repeatedly +applying `f`. ## Properties -### The two definitions of iterating are homotopic - -```agda -module _ - {l : Level} {X : UU l} - where - - reassociate-iterate-succ-ℕ : - (k : ℕ) (f : X → X) (x : X) → iterate (succ-ℕ k) f x ＝ iterate k f (f x) - reassociate-iterate-succ-ℕ zero-ℕ f x = refl - reassociate-iterate-succ-ℕ (succ-ℕ k) f x = - ap f (reassociate-iterate-succ-ℕ k f x) - - reassociate-iterate : (k : ℕ) (f : X → X) → iterate k f ~ iterate' k f - reassociate-iterate zero-ℕ f x = refl - reassociate-iterate (succ-ℕ k) f x = - reassociate-iterate-succ-ℕ k f x ∙ reassociate-iterate k f (f x) -``` - ### For any map `f : X → X`, iterating `f` defines a monoid action of ℕ on `X` ```agda diff --git a/src/set-theory/cantors-diagonal-argument.lagda.md b/src/set-theory/cantors-diagonal-argument.lagda.md index b573aa9ab7..083b3aff85 100644 --- a/src/set-theory/cantors-diagonal-argument.lagda.md +++ b/src/set-theory/cantors-diagonal-argument.lagda.md @@ -33,6 +33,8 @@ open import foundation-core.empty-types open import foundation-core.fibers-of-maps open import foundation-core.propositions +open import logic.propositionally-decidable-types + open import set-theory.countable-sets open import set-theory.infinite-sets open import set-theory.uncountable-sets From b8815f7bb0ba2ab89b60371d1da309cefd81eadb Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Fri, 28 Mar 2025 17:21:09 +0000 Subject: [PATCH 07/20] pre-commit --- src/foundation-core.lagda.md | 1 + 1 file changed, 1 insertion(+) diff --git a/src/foundation-core.lagda.md b/src/foundation-core.lagda.md index 9b9dd2512c..ea01876a8c 100644 --- a/src/foundation-core.lagda.md +++ b/src/foundation-core.lagda.md @@ -36,6 +36,7 @@ open import foundation-core.homotopies public open import foundation-core.identity-types public open import foundation-core.injective-maps public open import foundation-core.invertible-maps public +open import foundation-core.iterating-functions public open import foundation-core.negation public open import foundation-core.operations-span-diagrams public open import foundation-core.operations-spans public From 2141395b4494d59d480042ed7c08d76fb110d5cb Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Sat, 29 Mar 2025 09:53:47 +0000 Subject: [PATCH 08/20] refactor injective double negation eliminating maps are embeddings --- .../double-negation-images.lagda.md | 43 ++++++++++++++----- 1 file changed, 33 insertions(+), 10 deletions(-) diff --git a/src/foundation/double-negation-images.lagda.md b/src/foundation/double-negation-images.lagda.md index c6c10ecf79..b40531f33d 100644 --- a/src/foundation/double-negation-images.lagda.md +++ b/src/foundation/double-negation-images.lagda.md @@ -22,6 +22,7 @@ open import foundation-core.1-types open import foundation-core.commuting-triangles-of-maps open import foundation-core.equivalences open import foundation-core.fibers-of-maps +open import foundation-core.sections open import foundation-core.identity-types open import foundation-core.injective-maps open import foundation-core.propositions @@ -275,6 +276,37 @@ module _ {l1 l2 : Level} {X : UU l1} {A : UU l2} {f : A → X} where + map-section-map-unit-double-negation-im : + is-double-negation-eliminating-map f → double-negation-im f → A + map-section-map-unit-double-negation-im K (y , p) = pr1 (K y p) + + is-section-map-section-map-unit-double-negation-im : + (K : is-double-negation-eliminating-map f) → + is-section + ( map-unit-double-negation-im f) + ( map-section-map-unit-double-negation-im K) + is-section-map-section-map-unit-double-negation-im K (y , p) = + is-injective-inclusion-double-negation-im f (pr2 (K y p)) + + section-map-unit-double-negation-im : + is-double-negation-eliminating-map f → + section (map-unit-double-negation-im f) + section-map-unit-double-negation-im K = + ( map-section-map-unit-double-negation-im K , + is-section-map-section-map-unit-double-negation-im K) + + is-equiv-map-unit-double-negation-im : + is-double-negation-eliminating-map f → + is-injective f → + is-equiv (map-unit-double-negation-im f) + is-equiv-map-unit-double-negation-im K H = + is-equiv-is-injective + ( section-map-unit-double-negation-im K) + ( is-injective-right-factor + ( inclusion-double-negation-im f) + ( map-unit-double-negation-im f) + ( H)) + is-emb-is-injective-is-double-negation-eliminating-map : is-double-negation-eliminating-map f → is-injective f → is-emb f is-emb-is-injective-is-double-negation-eliminating-map K H = @@ -282,16 +314,7 @@ module _ ( inclusion-double-negation-im f) ( map-unit-double-negation-im f) ( is-emb-inclusion-double-negation-im f) - ( is-emb-is-equiv - ( is-equiv-is-split-surjective-is-injective - ( map-unit-double-negation-im f) - ( is-injective-right-factor - ( inclusion-double-negation-im f) - ( map-unit-double-negation-im f) H) - ( λ x → - pr1 (K (pr1 x) (pr2 x)) , - is-injective-inclusion-double-negation-im f - ( pr2 (K (pr1 x) (pr2 x)))))) + ( is-emb-is-equiv (is-equiv-map-unit-double-negation-im K H)) ``` ## See also From 4a89cd8c25b8f84dd3776b93e220c12d1728ac71 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Sat, 29 Mar 2025 09:59:19 +0000 Subject: [PATCH 09/20] fix --- references.bib | 24 +++++++++++++++++++ .../double-negation-images.lagda.md | 8 +++---- 2 files changed, 28 insertions(+), 4 deletions(-) diff --git a/references.bib b/references.bib index f63c1f2c16..6c02da9a26 100644 --- a/references.bib +++ b/references.bib @@ -258,6 +258,15 @@ @online{DavidJaz/Cohesion howpublished = {{{GitHub}} repository} } +@misc{Diener18, + title = {Constructive Reverse Mathematics}, + author = {Hannes Diener}, + year = {2018}, + eprint = {1804.05495}, + archiveprefix = {arXiv}, + primaryclass = {math.LO} +} + @article{dJE23, title = {{On Small Types in Univalent Foundations}}, author = {de Jong, Tom and Escardó, Martín Hötzel}, @@ -333,6 +342,21 @@ @article{Esc08 primaryclass = {cs.LO} } +@article{Esc13, + author = {Escardó, Martín Hötzel}, + title = {Infinite sets that satisfy the principle of omniscience in any + variety of constructive mathematics}, + journal = {The Journal of Symbolic Logic}, + volume = {78}, + year = {2013}, + number = {3}, + pages = {764--784}, + issn = {0022-4812,1943-5886}, + mrclass = {03F50 (03F55)}, + mrnumber = {3135497}, + mrreviewer = {Paulo\ Oliva} +} + @online{Esc17YetAnother, title = {Yet another characterization of univalence}, author = {Escardó, Martín Hötzel}, diff --git a/src/foundation/double-negation-images.lagda.md b/src/foundation/double-negation-images.lagda.md index b40531f33d..9cdeac3c3d 100644 --- a/src/foundation/double-negation-images.lagda.md +++ b/src/foundation/double-negation-images.lagda.md @@ -22,10 +22,10 @@ open import foundation-core.1-types open import foundation-core.commuting-triangles-of-maps open import foundation-core.equivalences open import foundation-core.fibers-of-maps -open import foundation-core.sections open import foundation-core.identity-types open import foundation-core.injective-maps open import foundation-core.propositions +open import foundation-core.sections open import foundation-core.sets open import foundation-core.subtypes open import foundation-core.torsorial-type-families @@ -296,9 +296,9 @@ module _ is-section-map-section-map-unit-double-negation-im K) is-equiv-map-unit-double-negation-im : - is-double-negation-eliminating-map f → - is-injective f → - is-equiv (map-unit-double-negation-im f) + is-double-negation-eliminating-map f → + is-injective f → + is-equiv (map-unit-double-negation-im f) is-equiv-map-unit-double-negation-im K H = is-equiv-is-injective ( section-map-unit-double-negation-im K) From e923911ee624f8b5194920016d7e4c5087818f2d Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Mon, 31 Mar 2025 12:01:27 +0100 Subject: [PATCH 10/20] review --- .../decidable-propositions.lagda.md | 40 ++++--- src/foundation/cantors-theorem.lagda.md | 108 ++++++++++-------- ...ecidable-dependent-function-types.lagda.md | 29 ++--- src/foundation/decidable-maps.lagda.md | 15 +-- .../decidable-type-families.lagda.md | 18 +-- src/foundation/decidable-types.lagda.md | 2 +- .../double-negation-images.lagda.md | 2 +- src/foundation/inequality-booleans.lagda.md | 52 ++++----- 8 files changed, 141 insertions(+), 125 deletions(-) diff --git a/src/foundation-core/decidable-propositions.lagda.md b/src/foundation-core/decidable-propositions.lagda.md index 6c69978020..d643fb95ef 100644 --- a/src/foundation-core/decidable-propositions.lagda.md +++ b/src/foundation-core/decidable-propositions.lagda.md @@ -263,29 +263,33 @@ module _ {l1 l2 : Level} {P : UU l1} {Q : UU l2} where - is-decidable-prop-function-type' : - is-decidable P → (P → is-decidable-prop Q) → is-decidable-prop (P → Q) - is-decidable-prop-function-type' H K = - ( rec-coproduct - ( λ p → is-prop-function-type (is-prop-type-is-decidable-prop (K p))) - ( λ np → is-prop-is-contr (universal-property-empty-is-empty P np Q)) - ( H)) , - ( is-decidable-function-type' H (is-decidable-type-is-decidable-prop ∘ K)) - - is-decidable-prop-function-type : - is-decidable P → is-decidable-prop Q → is-decidable-prop (P → Q) - is-decidable-prop-function-type H K = - ( is-prop-function-type (is-prop-type-is-decidable-prop K)) , - ( is-decidable-function-type H (is-decidable-type-is-decidable-prop K)) + abstract + is-decidable-prop-function-type' : + is-decidable P → (P → is-decidable-prop Q) → is-decidable-prop (P → Q) + pr1 (is-decidable-prop-function-type' H K) = + rec-coproduct + ( λ p → is-prop-function-type (is-prop-type-is-decidable-prop (K p))) + ( λ np → is-prop-is-contr (universal-property-empty-is-empty P np Q)) + ( H) + pr2 (is-decidable-prop-function-type' H K) = + is-decidable-function-type' H (is-decidable-type-is-decidable-prop ∘ K) + + abstract + is-decidable-prop-function-type : + is-decidable P → is-decidable-prop Q → is-decidable-prop (P → Q) + pr1 (is-decidable-prop-function-type H K) = + is-prop-function-type (is-prop-type-is-decidable-prop K) + pr2 (is-decidable-prop-function-type H K) = + is-decidable-function-type H (is-decidable-type-is-decidable-prop K) hom-Decidable-Prop : {l1 l2 : Level} → Decidable-Prop l1 → Decidable-Prop l2 → Decidable-Prop (l1 ⊔ l2) -hom-Decidable-Prop P Q = - ( type-Decidable-Prop P → type-Decidable-Prop Q) , - ( is-decidable-prop-function-type +pr1 (hom-Decidable-Prop P Q) = type-Decidable-Prop P → type-Decidable-Prop Q +pr2 (hom-Decidable-Prop P Q) = + is-decidable-prop-function-type ( is-decidable-Decidable-Prop P) - ( is-decidable-prop-type-Decidable-Prop Q)) + ( is-decidable-prop-type-Decidable-Prop Q) ``` ### Dependent products of decidable propositions diff --git a/src/foundation/cantors-theorem.lagda.md b/src/foundation/cantors-theorem.lagda.md index 2abcbd3a35..f2a049ca31 100644 --- a/src/foundation/cantors-theorem.lagda.md +++ b/src/foundation/cantors-theorem.lagda.md @@ -40,6 +40,11 @@ shows that there is [no](foundation-core.negation.md) ¬ (A ↠ 𝒫(A)) ``` +In fact, no map `A → PA` into a +[complement](foundation.complements-subtypes.md)-closed +[subset](foundation-core.subtypes.md) `PA` of the powerset may be +[double negation dense](logic.double-negation-dense-maps.md). + ## Theorem **Proof.** The proof is an instance of an argument _by diagonalization_. Given a @@ -72,22 +77,24 @@ module _ subtype-theorem-Cantor : powerset l2 X subtype-theorem-Cantor x = neg-Prop (f x x) - not-in-image-subtype-theorem-Cantor : ¬ (fiber f subtype-theorem-Cantor) - not-in-image-subtype-theorem-Cantor (ξ , α) = - no-fixed-points-neg-Prop (f ξ ξ) (iff-eq (htpy-eq α ξ)) + abstract + not-in-image-subtype-theorem-Cantor : ¬ (fiber f subtype-theorem-Cantor) + not-in-image-subtype-theorem-Cantor (ξ , α) = + no-fixed-points-neg-Prop (f ξ ξ) (iff-eq (htpy-eq α ξ)) - theorem-double-negation-dense-Cantor : ¬ (is-double-negation-dense-map f) - theorem-double-negation-dense-Cantor H = - H subtype-theorem-Cantor not-in-image-subtype-theorem-Cantor + theorem-double-negation-dense-Cantor : ¬ (is-double-negation-dense-map f) + theorem-double-negation-dense-Cantor H = + H subtype-theorem-Cantor not-in-image-subtype-theorem-Cantor - abstract theorem-Cantor : ¬ (is-surjective f) theorem-Cantor = map-neg - is-double-negation-dense-map-is-surjective - theorem-double-negation-dense-Cantor + ( is-double-negation-dense-map-is-surjective) + ( theorem-double-negation-dense-Cantor) ``` +## Alternative statements + ### Cantor's theorem for the set of decidable subtypes **Statement.** There is no surjective map from a type `X` to its set of @@ -101,20 +108,21 @@ module _ map-theorem-decidable-Cantor : decidable-subtype l2 X map-theorem-decidable-Cantor x = neg-Decidable-Prop (f x x) - not-in-image-map-theorem-decidable-Cantor : - ¬ (fiber f map-theorem-decidable-Cantor) - not-in-image-map-theorem-decidable-Cantor (x , α) = - no-fixed-points-neg-Decidable-Prop - ( f x x) - ( iff-eq (ap prop-Decidable-Prop (htpy-eq α x))) - - theorem-double-negation-dense-decidable-Cantor : - ¬ (is-double-negation-dense-map f) - theorem-double-negation-dense-decidable-Cantor H = - H map-theorem-decidable-Cantor not-in-image-map-theorem-decidable-Cantor - abstract - theorem-decidable-Cantor : ¬ (is-surjective f) + not-in-image-map-theorem-decidable-Cantor : + ¬ (fiber f map-theorem-decidable-Cantor) + not-in-image-map-theorem-decidable-Cantor (x , α) = + no-fixed-points-neg-Decidable-Prop + ( f x x) + ( iff-eq (ap prop-Decidable-Prop (htpy-eq α x))) + + theorem-double-negation-dense-decidable-Cantor : + ¬ (is-double-negation-dense-map f) + theorem-double-negation-dense-decidable-Cantor H = + H map-theorem-decidable-Cantor not-in-image-map-theorem-decidable-Cantor + + theorem-decidable-Cantor : + ¬ (is-surjective f) theorem-decidable-Cantor = map-neg is-double-negation-dense-map-is-surjective @@ -136,21 +144,22 @@ module _ map-theorem-double-negation-stable-Cantor x = neg-Double-Negation-Stable-Prop (f x x) - not-in-image-map-theorem-double-negation-stable-Cantor : - ¬ (fiber f map-theorem-double-negation-stable-Cantor) - not-in-image-map-theorem-double-negation-stable-Cantor (x , α) = - no-fixed-points-neg-Double-Negation-Stable-Prop - ( f x x) - ( iff-eq (ap prop-Double-Negation-Stable-Prop (htpy-eq α x))) - - theorem-double-negation-dense-double-negation-stable-Cantor : - ¬ (is-double-negation-dense-map f) - theorem-double-negation-dense-double-negation-stable-Cantor H = - H map-theorem-double-negation-stable-Cantor - not-in-image-map-theorem-double-negation-stable-Cantor - abstract - theorem-double-negation-stable-Cantor : ¬ (is-surjective f) + not-in-image-map-theorem-double-negation-stable-Cantor : + ¬ (fiber f map-theorem-double-negation-stable-Cantor) + not-in-image-map-theorem-double-negation-stable-Cantor (x , α) = + no-fixed-points-neg-Double-Negation-Stable-Prop + ( f x x) + ( iff-eq (ap prop-Double-Negation-Stable-Prop (htpy-eq α x))) + + theorem-double-negation-dense-double-negation-stable-Cantor : + ¬ (is-double-negation-dense-map f) + theorem-double-negation-dense-double-negation-stable-Cantor H = + H map-theorem-double-negation-stable-Cantor + not-in-image-map-theorem-double-negation-stable-Cantor + + theorem-double-negation-stable-Cantor : + ¬ (is-surjective f) theorem-double-negation-stable-Cantor = map-neg is-double-negation-dense-map-is-surjective @@ -170,20 +179,21 @@ module _ map-theorem-de-morgan-Cantor : de-morgan-subtype l2 X map-theorem-de-morgan-Cantor x = neg-De-Morgan-Prop (f x x) - not-in-image-map-theorem-de-morgan-Cantor : - ¬ (fiber f map-theorem-de-morgan-Cantor) - not-in-image-map-theorem-de-morgan-Cantor (x , α) = - no-fixed-points-neg-De-Morgan-Prop - ( f x x) - ( iff-eq (ap prop-De-Morgan-Prop (htpy-eq α x))) - - theorem-double-negation-dense-de-morgan-Cantor : - ¬ (is-double-negation-dense-map f) - theorem-double-negation-dense-de-morgan-Cantor H = - H map-theorem-de-morgan-Cantor not-in-image-map-theorem-de-morgan-Cantor - abstract - theorem-de-morgan-Cantor : ¬ (is-surjective f) + not-in-image-map-theorem-de-morgan-Cantor : + ¬ (fiber f map-theorem-de-morgan-Cantor) + not-in-image-map-theorem-de-morgan-Cantor (x , α) = + no-fixed-points-neg-De-Morgan-Prop + ( f x x) + ( iff-eq (ap prop-De-Morgan-Prop (htpy-eq α x))) + + theorem-double-negation-dense-de-morgan-Cantor : + ¬ (is-double-negation-dense-map f) + theorem-double-negation-dense-de-morgan-Cantor H = + H map-theorem-de-morgan-Cantor not-in-image-map-theorem-de-morgan-Cantor + + theorem-de-morgan-Cantor : + ¬ (is-surjective f) theorem-de-morgan-Cantor = map-neg is-double-negation-dense-map-is-surjective diff --git a/src/foundation/decidable-dependent-function-types.lagda.md b/src/foundation/decidable-dependent-function-types.lagda.md index d97239bda0..c90995cca8 100644 --- a/src/foundation/decidable-dependent-function-types.lagda.md +++ b/src/foundation/decidable-dependent-function-types.lagda.md @@ -53,14 +53,15 @@ is-decidable-Π-uniformly-decidable-family (inl a) (inr b) = is-decidable-Π-uniformly-decidable-family (inr na) _ = inl (ex-falso ∘ na) -is-decidable-prop-Π-uniformly-decidable-family : - {l1 l2 : Level} {A : UU l1} {B : A → UU l2} → - is-decidable A → - is-uniformly-decidable-family B → - ((x : A) → is-prop (B x)) → - is-decidable-prop ((a : A) → (B a)) -is-decidable-prop-Π-uniformly-decidable-family dA dB H = - ( is-prop-Π H , is-decidable-Π-uniformly-decidable-family dA dB) +abstract + is-decidable-prop-Π-uniformly-decidable-family : + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} → + is-decidable A → + is-uniformly-decidable-family B → + ((x : A) → is-prop (B x)) → + is-decidable-prop ((a : A) → (B a)) + is-decidable-prop-Π-uniformly-decidable-family dA dB H = + ( is-prop-Π H , is-decidable-Π-uniformly-decidable-family dA dB) abstract is-decidable-prop-Π-uniformly-decidable-family' : @@ -122,7 +123,7 @@ module _ is-decidable-Π-uniformly-decidable-family dA ( is-uniformly-decidable-family-all-elements-merely-equal-base ( H) - ( is-decidable-Decidable-Prop ∘ B) + ( λ x → is-decidable-Decidable-Prop (B x)) ( dA)) is-decidable-prop-Π-all-elements-merely-equal-base : @@ -133,9 +134,9 @@ module _ is-decidable-prop-Π-uniformly-decidable-family dA ( is-uniformly-decidable-family-all-elements-merely-equal-base ( H) - ( is-decidable-Decidable-Prop ∘ B) + ( λ x → is-decidable-Decidable-Prop (B x)) ( dA)) - ( is-prop-type-Decidable-Prop ∘ B) + ( λ x → is-prop-type-Decidable-Prop (B x)) is-decidable-prop-Π-all-elements-merely-equal-base' : all-elements-merely-equal A → @@ -145,10 +146,10 @@ module _ is-decidable-prop-Π-uniformly-decidable-family' dA ( is-uniformly-decidable-family-all-elements-merely-equal-base' ( H) - ( is-decidable-Decidable-Prop ∘ B) + ( λ x → is-decidable-Decidable-Prop (B x)) ( dA) - ( is-prop-type-Decidable-Prop ∘ B)) - ( is-prop-type-Decidable-Prop ∘ B) + ( λ x → is-prop-type-Decidable-Prop (B x))) + ( λ x → is-prop-type-Decidable-Prop (B x)) ``` ### Decidability of dependent products over an equivalence diff --git a/src/foundation/decidable-maps.lagda.md b/src/foundation/decidable-maps.lagda.md index fa0d3711df..0d9c4bbba3 100644 --- a/src/foundation/decidable-maps.lagda.md +++ b/src/foundation/decidable-maps.lagda.md @@ -83,13 +83,14 @@ module _ ### Decidable maps are closed under homotopy ```agda -is-decidable-map-htpy : - {l1 l2 : Level} {A : UU l1} {B : UU l2} {f g : A → B} → - f ~ g → is-decidable-map g → is-decidable-map f -is-decidable-map-htpy H K b = - is-decidable-equiv - ( equiv-tot (λ a → equiv-concat (inv (H a)) b)) - ( K b) +opaque + is-decidable-map-htpy : + {l1 l2 : Level} {A : UU l1} {B : UU l2} {f g : A → B} → + f ~ g → is-decidable-map g → is-decidable-map f + is-decidable-map-htpy H K b = + is-decidable-equiv + ( equiv-tot (λ a → equiv-concat (inv (H a)) b)) + ( K b) ``` ### Composition of decidable maps diff --git a/src/foundation/decidable-type-families.lagda.md b/src/foundation/decidable-type-families.lagda.md index 385f928a49..78ffff9807 100644 --- a/src/foundation/decidable-type-families.lagda.md +++ b/src/foundation/decidable-type-families.lagda.md @@ -1,4 +1,4 @@ -# Decidable families +# Decidable type families ```agda module foundation.decidable-type-families where @@ -28,9 +28,9 @@ open import foundation-core.identity-types A type family `B : A → 𝒰` is said to be {{#concept "decidable" Disambiguation="type family" Agda=is-decidable-family}} -if we, for every `x : A`, can either construct an element of `B x`, or we can -prove that it is [empty](foundation-core.empty-types.md). In other words, we -interpret decidability via the +if we can for every `x : A` either construct an element of `B x` or we can prove +that it is [empty](foundation-core.empty-types.md). In other words, we interpret +decidability via the [Curry–Howard interpretation](https://en.wikipedia.org/wiki/Curry–Howard_correspondence) of logic into type theory. A related concept is that a type family is either [inhabited](foundation.inhabited-types.md) or empty, where inhabitedness of a @@ -70,15 +70,15 @@ decidable-family-decidable-subtype P = ## Properties -### Reindexing decidable type families +### Base change of decidable type families ```agda module _ {l1 l2 l3 : Level} {A : UU l1} {B : UU l2} (P : decidable-family l3 B) where - reindex-decidable-family : (f : A → B) → decidable-family l3 A - reindex-decidable-family f = + base-change-decidable-family : (f : A → B) → decidable-family l3 A + base-change-decidable-family f = ( family-decidable-family P ∘ f , is-decidable-decidable-family P ∘ f) ``` @@ -103,7 +103,7 @@ module _ Given a decidable family of types with double negation dense equality `P : A → 𝒰` and a decidable type family `Q : (x : A) → P x → 𝒰` then we may -_compose_ `Q` after `P` and obtain a decidabe type family `Q ∘ P : A → 𝒰`. +_compose_ `Q` after `P` and obtain a decidable type family `Q ∘ P : A → 𝒰`. ```agda module _ @@ -131,7 +131,7 @@ module _ ( λ r → nq (tr (family-decidable-family (Q x)) (inv r) (pr2 q))))) ( is-decidable-decidable-family (Q x) p)) - (λ np → inr (map-neg pr1 np)) + ( λ np → inr (map-neg pr1 np)) ( is-decidable-decidable-family P x) comp-decidable-family-decidable-subtype' : diff --git a/src/foundation/decidable-types.lagda.md b/src/foundation/decidable-types.lagda.md index f23da39218..bd0e8a5b9a 100644 --- a/src/foundation/decidable-types.lagda.md +++ b/src/foundation/decidable-types.lagda.md @@ -315,7 +315,7 @@ is-decidable-Σ-has-double-negation-dense-equality-base hP (inr np) _ = inr (map-neg pr1 np) ``` -### Raising universe level conserves decidability +### Raising universe level preserves decidability ```agda module _ diff --git a/src/foundation/double-negation-images.lagda.md b/src/foundation/double-negation-images.lagda.md index 9cdeac3c3d..4077fa59ba 100644 --- a/src/foundation/double-negation-images.lagda.md +++ b/src/foundation/double-negation-images.lagda.md @@ -251,7 +251,7 @@ abstract double-negation-im-Set : {l1 l2 : Level} (X : Set l1) {A : UU l2} (f : A → type-Set X) → Set (l1 ⊔ l2) -double-negation-im-Set = double-negation-im-Truncated-Type (neg-one-𝕋) +double-negation-im-Set = double-negation-im-Truncated-Type neg-one-𝕋 ``` ### The double negation image of a map into a 1-type is a 1-type diff --git a/src/foundation/inequality-booleans.lagda.md b/src/foundation/inequality-booleans.lagda.md index 48c3f4f6ad..e49d787d4d 100644 --- a/src/foundation/inequality-booleans.lagda.md +++ b/src/foundation/inequality-booleans.lagda.md @@ -32,7 +32,7 @@ open import order-theory.total-orders ## Idea The -{{#concept "standard inequality relation" Disambiguation="on booleans" Agda=}} +{{#concept "standard inequality relation" Disambiguation="on booleans" Agda=leq-bool}} on [booleans](foundation.booleans.md) is the inductively defined [relation](foundation.binary-relations.md) given by the four inequalities @@ -155,15 +155,15 @@ bool-Decidable-Total-Order = ### Interactions between the inequality relation and the disjunction operation ```agda -leq-or-bool : {x y : bool} → leq-bool x (or-bool x y) -leq-or-bool {true} {y} = star -leq-or-bool {false} {y} = star +left-leq-or-bool : {x y : bool} → leq-bool x (or-bool x y) +left-leq-or-bool {true} {y} = star +left-leq-or-bool {false} {y} = star -leq-or-bool' : {x y : bool} → leq-bool y (or-bool x y) -leq-or-bool' {true} {true} = star -leq-or-bool' {true} {false} = star -leq-or-bool' {false} {true} = star -leq-or-bool' {false} {false} = star +right-leq-or-bool : {x y : bool} → leq-bool y (or-bool x y) +right-leq-or-bool {true} {true} = star +right-leq-or-bool {true} {false} = star +right-leq-or-bool {false} {true} = star +right-leq-or-bool {false} {false} = star leq-left-or-bool : {x y : bool} → leq-bool x y → leq-bool (or-bool x y) y leq-left-or-bool {true} {true} p = star @@ -174,27 +174,27 @@ leq-right-or-bool : {x y : bool} → leq-bool x y → leq-bool (or-bool y x) y leq-right-or-bool {x} {true} p = star leq-right-or-bool {false} {false} p = star -leq-or-bool'' : +is-upper-bound-or-bool : {x y z : bool} → leq-bool x z → leq-bool y z → leq-bool (or-bool x y) z -leq-or-bool'' {true} {y} {true} p q = star -leq-or-bool'' {false} {true} {true} p q = star -leq-or-bool'' {false} {false} {true} p q = star -leq-or-bool'' {false} {false} {false} p q = star +is-upper-bound-or-bool {true} {y} {true} p q = star +is-upper-bound-or-bool {false} {true} {true} p q = star +is-upper-bound-or-bool {false} {false} {true} p q = star +is-upper-bound-or-bool {false} {false} {false} p q = star ``` ### Interactions between the inequality relation and the conjunction operation ```agda -leq-and-bool : {x y : bool} → leq-bool (and-bool x y) x -leq-and-bool {true} {true} = star -leq-and-bool {false} {true} = star -leq-and-bool {true} {false} = star -leq-and-bool {false} {false} = star +left-leq-and-bool : {x y : bool} → leq-bool (and-bool x y) x +left-leq-and-bool {true} {true} = star +left-leq-and-bool {false} {true} = star +left-leq-and-bool {true} {false} = star +left-leq-and-bool {false} {false} = star -leq-and-bool' : {x y : bool} → leq-bool (and-bool x y) y -leq-and-bool' {true} {true} = star -leq-and-bool' {true} {false} = star -leq-and-bool' {false} {y} = star +right-leq-and-bool : {x y : bool} → leq-bool (and-bool x y) y +right-leq-and-bool {true} {true} = star +right-leq-and-bool {true} {false} = star +right-leq-and-bool {false} {y} = star leq-left-and-bool : {x y : bool} → leq-bool x y → leq-bool x (and-bool x y) leq-left-and-bool {true} {true} p = star @@ -204,10 +204,10 @@ leq-right-and-bool : {x y : bool} → leq-bool x y → leq-bool x (and-bool y x) leq-right-and-bool {true} {true} p = star leq-right-and-bool {false} {y} p = star -leq-and-bool'' : +is-lower-bound-and-bool : {x y z : bool} → leq-bool x y → leq-bool x z → leq-bool x (and-bool y z) -leq-and-bool'' {true} {true} {true} p q = star -leq-and-bool'' {false} {y} {z} p q = star +is-lower-bound-and-bool {true} {true} {true} p q = star +is-lower-bound-and-bool {false} {y} {z} p q = star ``` ```agda From be7e07920c1920431e8c88213bf8844ba7fe456d Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Mon, 31 Mar 2025 14:52:42 +0100 Subject: [PATCH 11/20] external link dirk gently --- src/logic/dirk-gentlys-principle.lagda.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/logic/dirk-gentlys-principle.lagda.md b/src/logic/dirk-gentlys-principle.lagda.md index 3b8f8c0ef6..b0bececce5 100644 --- a/src/logic/dirk-gentlys-principle.lagda.md +++ b/src/logic/dirk-gentlys-principle.lagda.md @@ -66,3 +66,9 @@ true or false, so since false ≤ true, we are done. ## References {{#bibliography}} + +## External links + +- This principle is studied under the name _Dummett's linearity axiom_ in + [`Various.DummettDisjunction`](https://martinescardo.github.io/TypeTopology/Various.DummettDisjunction.html) + at TypeTopology From b3ee7e69bd0d52f2d747a0f82cbe59dc90ea3020 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Fri, 6 Jun 2025 11:24:45 +0100 Subject: [PATCH 12/20] review 1 --- src/foundation/cantors-theorem.lagda.md | 4 ++-- .../decidable-dependent-function-types.lagda.md | 6 +++--- .../decidable-dependent-pair-types.lagda.md | 4 +++- src/foundation/decidable-maps.lagda.md | 11 +++++++++++ 4 files changed, 19 insertions(+), 6 deletions(-) diff --git a/src/foundation/cantors-theorem.lagda.md b/src/foundation/cantors-theorem.lagda.md index f2a049ca31..1ec52a1179 100644 --- a/src/foundation/cantors-theorem.lagda.md +++ b/src/foundation/cantors-theorem.lagda.md @@ -125,8 +125,8 @@ module _ ¬ (is-surjective f) theorem-decidable-Cantor = map-neg - is-double-negation-dense-map-is-surjective - theorem-double-negation-dense-decidable-Cantor + ( is-double-negation-dense-map-is-surjective) + ( theorem-double-negation-dense-decidable-Cantor) ``` ### Cantor's theorem for the set of double negation stable subtypes diff --git a/src/foundation/decidable-dependent-function-types.lagda.md b/src/foundation/decidable-dependent-function-types.lagda.md index c90995cca8..9897f344d7 100644 --- a/src/foundation/decidable-dependent-function-types.lagda.md +++ b/src/foundation/decidable-dependent-function-types.lagda.md @@ -105,10 +105,10 @@ is-decidable-Π-Maybe {B = B} du de = ( is-decidable-product du de) ``` -### Dependent products of decidable propositions over a base with mere equality are decidable propositions +### Dependent products of decidable propositions over a base with all elements merely equal are decidable propositions -Assuming the base `A` is empty or 0-connected, a dependent product of decidable -propositions over `A` is again a decidable proposition. +Assuming that all elements are merely equal in a type `A` then a dependent +product of decidable propositions over `A` is again a decidable proposition. ```agda module _ diff --git a/src/foundation/decidable-dependent-pair-types.lagda.md b/src/foundation/decidable-dependent-pair-types.lagda.md index fa971b4c7a..59db806060 100644 --- a/src/foundation/decidable-dependent-pair-types.lagda.md +++ b/src/foundation/decidable-dependent-pair-types.lagda.md @@ -98,7 +98,9 @@ is-decidable-Σ-Maybe {A = A} {B} dA de = This is a special case of the more general fact that a type has decidable sums if and only if its totally separated reflection does, and totally separated -types have double negation stable equality. {{#cite TypeTopology}} +types have double negation stable equality. +[`TypeTopology.TotallySeparated`](http://martinescardo.github.io/TypeTopology/TypeTopology.TotallySeparated.html) +{{#cite TypeTopology}} ```agda module _ diff --git a/src/foundation/decidable-maps.lagda.md b/src/foundation/decidable-maps.lagda.md index 0d9c4bbba3..ddd409b4fb 100644 --- a/src/foundation/decidable-maps.lagda.md +++ b/src/foundation/decidable-maps.lagda.md @@ -284,6 +284,17 @@ module _ ### Decidable maps have Hilbert ε-operators +A decidable map `f` induces "eliminators" on the propositional truncations of +its fibers + +```text + ε : (x : A) → ║ fiber f x ║₋₁ → fiber f x. +``` + +Such "eliminators" are called +[Hilbert ε-operators](foundation.hilbert-epsilon-operators-maps.md), or _split +supports_. + ```agda ε-operator-map-is-decidable-map : {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} → From 118c573d6d584d29f8eda7d9c4f9b70bd7746f79 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Fri, 6 Jun 2025 11:25:25 +0100 Subject: [PATCH 13/20] Update src/logic/propositionally-double-negation-eliminating-maps.lagda.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vojtěch Štěpančík --- .../propositionally-double-negation-eliminating-maps.lagda.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/logic/propositionally-double-negation-eliminating-maps.lagda.md b/src/logic/propositionally-double-negation-eliminating-maps.lagda.md index 446cfea6f7..8f869971b1 100644 --- a/src/logic/propositionally-double-negation-eliminating-maps.lagda.md +++ b/src/logic/propositionally-double-negation-eliminating-maps.lagda.md @@ -30,7 +30,7 @@ A [map](foundation-core.function-types.md) is said to be if its [fibers](foundation-core.fibers-of-maps.md) satisfy [propositional double negation elimination](logic.propositional-double-negation-elimination.md). I.e., for every `y : B`, if `fiber f y` is -[irrefutable](foundation.irrefutable-propositions.md), then we have then the +[irrefutable](foundation.irrefutable-propositions.md), then we have that the fiber is in fact inhabited. In other words, double negation eliminating maps come [equipped](foundation.structure.md) with a map From b29b285b41391f2b1dec6de287bf3ac41ce647c9 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Fri, 6 Jun 2025 11:28:19 +0100 Subject: [PATCH 14/20] pre-commit --- references.bib | 27 +++++++++---------- ...-double-negation-eliminating-maps.lagda.md | 2 +- 2 files changed, 14 insertions(+), 15 deletions(-) diff --git a/references.bib b/references.bib index 294774c821..048a8f2630 100644 --- a/references.bib +++ b/references.bib @@ -292,10 +292,10 @@ @online{DavidJaz/Cohesion @misc{Diener18, title = {Constructive Reverse Mathematics}, author = {Hannes Diener}, - year = {2018}, + year = 2018, eprint = {1804.05495}, archiveprefix = {arXiv}, - primaryclass = {math.LO} + primaryclass = {math.LO}, } @article{dJE23, @@ -374,18 +374,17 @@ @article{Esc08 } @article{Esc13, - author = {Escardó, Martín Hötzel}, - title = {Infinite sets that satisfy the principle of omniscience in any - variety of constructive mathematics}, - journal = {The Journal of Symbolic Logic}, - volume = {78}, - year = {2013}, - number = {3}, - pages = {764--784}, - issn = {0022-4812,1943-5886}, - mrclass = {03F50 (03F55)}, - mrnumber = {3135497}, - mrreviewer = {Paulo\ Oliva} + title = {Infinite sets that satisfy the principle of omniscience in any variety of constructive mathematics}, + author = {Escardó, Martín Hötzel}, + year = 2013, + journal = {The Journal of Symbolic Logic}, + volume = 78, + number = 3, + pages = {764--784}, + issn = {0022-4812,1943-5886}, + mrclass = {03F50 (03F55)}, + mrnumber = 3135497, + mrreviewer = {Paulo\ Oliva}, } @online{Esc17YetAnother, diff --git a/src/logic/propositionally-double-negation-eliminating-maps.lagda.md b/src/logic/propositionally-double-negation-eliminating-maps.lagda.md index 8f869971b1..7738cf2653 100644 --- a/src/logic/propositionally-double-negation-eliminating-maps.lagda.md +++ b/src/logic/propositionally-double-negation-eliminating-maps.lagda.md @@ -38,7 +38,7 @@ come [equipped](foundation.structure.md) with a map (y : B) → ¬¬ (fiber f y) → ║ fiber f y ║₋₁. ``` -## Definintion +## Definitions ### Propositional double negation elimination on a map From 363315f781f865b6edc60df0da28bfa0048eaca9 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Fri, 6 Jun 2025 13:28:59 +0100 Subject: [PATCH 15/20] diagram 3 for 2 --- src/foundation/decidable-maps.lagda.md | 17 +++++++++++++++-- .../hilbert-epsilon-operators-maps.lagda.md | 14 ++++++++++++++ 2 files changed, 29 insertions(+), 2 deletions(-) diff --git a/src/foundation/decidable-maps.lagda.md b/src/foundation/decidable-maps.lagda.md index ddd409b4fb..aae4c0c21e 100644 --- a/src/foundation/decidable-maps.lagda.md +++ b/src/foundation/decidable-maps.lagda.md @@ -307,7 +307,16 @@ supports_. **Proof.** Given a decidable map `f : A → B` then `f` decomposes `B ≃ (im f) + B∖(im f)`. Restricting to `im f` we have a section given by the Hilbert ε-operator on `f`. Now, by injectivity of `f` we know this restriction -map is an equivalence. Hence, by 3-for-2 `f` is also an embedding. +map is an equivalence. Hence, `f` is a composite of embeddings and so must be an +embedding as well. + +```text + im f ╰────→ im f + B\(im f) + ↟ ⋮ │ + │ ⋮ ~ │ ~ + │ ↓ f ↓ + A ────────────→ B +``` ```agda module _ @@ -320,4 +329,8 @@ module _ is-emb-is-injective-ε-operator-map (ε-operator-map-is-decidable-map H) K ``` -There is also an analogous proof using the double negation image. +There is also an analogous proof using the double negation image. This analogous +proof avoids the use of propositional truncations, but cannot be included here +due to introducing cyclic dependencies. See +[`foundation.double-negation-images`](foundation.double-negation-images.md) +instead. diff --git a/src/foundation/hilbert-epsilon-operators-maps.lagda.md b/src/foundation/hilbert-epsilon-operators-maps.lagda.md index 1c7dbdbbfd..1378faf499 100644 --- a/src/foundation/hilbert-epsilon-operators-maps.lagda.md +++ b/src/foundation/hilbert-epsilon-operators-maps.lagda.md @@ -74,6 +74,20 @@ module _ ### Injective maps with ε-operators are embeddings +**Proof.** Given a map `f : A → B` equipped with an ε-operator, then we have a +section of the image projection map `A ↠ im f` given by the Hilbert ε-operator. +Now, by injectivity of `f` we the image projection map must be an equivalence. +Hence, `f` is a composite of embeddings and so must be an embedding as well. + +```text + im f + ↟ ⋮ \ + │ ⋮ ~ \ + │ ↓ ∨ + A ──────→ B + f +``` + ```agda module _ {l1 l2 : Level} {A : UU l1} {B : UU l2} {f : A → B} From 693e4d7bbafe606cf2cedc0d27c76c15d759c123 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Sat, 7 Jun 2025 22:25:52 +0100 Subject: [PATCH 16/20] some more review --- src/foundation.lagda.md | 1 + .../decidable-type-families.lagda.md | 10 +- .../double-negation-dense-equality.lagda.md | 100 ++++++++++++++++++ .../double-negation-images.lagda.md | 52 +++++++-- src/foundation/double-negation.lagda.md | 6 +- src/foundation/irrefutable-equality.lagda.md | 60 ++--------- src/foundation/mere-equality.lagda.md | 19 ++-- 7 files changed, 180 insertions(+), 68 deletions(-) create mode 100644 src/foundation/double-negation-dense-equality.lagda.md diff --git a/src/foundation.lagda.md b/src/foundation.lagda.md index e41bdfe36e..7fa0c48a78 100644 --- a/src/foundation.lagda.md +++ b/src/foundation.lagda.md @@ -145,6 +145,7 @@ open import foundation.disjoint-subtypes public open import foundation.disjunction public open import foundation.double-arrows public open import foundation.double-negation public +open import foundation.double-negation-dense-equality public open import foundation.double-negation-dense-equality-maps public open import foundation.double-negation-images public open import foundation.double-negation-modality public diff --git a/src/foundation/decidable-type-families.lagda.md b/src/foundation/decidable-type-families.lagda.md index 78ffff9807..af47df982a 100644 --- a/src/foundation/decidable-type-families.lagda.md +++ b/src/foundation/decidable-type-families.lagda.md @@ -102,8 +102,14 @@ module _ ### Composition of decidable families Given a decidable family of types with double negation dense equality -`P : A → 𝒰` and a decidable type family `Q : (x : A) → P x → 𝒰` then we may -_compose_ `Q` after `P` and obtain a decidable type family `Q ∘ P : A → 𝒰`. +`P : A → 𝒰` and a decidable type family `Q : (x : A) → P x → 𝒰` then, via +[type duality](foundation.type-duality.md) we may _compose_ `Q` after `P` and +obtain a decidable type family `Q ∘ P : A → 𝒰`, defined on elements as +[dependent pair types](foundation.dependent-pair-types.md). + +```text + (Q ∘ P) x := Σ (y : P x), (Q x y). +``` ```agda module _ diff --git a/src/foundation/double-negation-dense-equality.lagda.md b/src/foundation/double-negation-dense-equality.lagda.md new file mode 100644 index 0000000000..e2594c6cc2 --- /dev/null +++ b/src/foundation/double-negation-dense-equality.lagda.md @@ -0,0 +1,100 @@ +# Double negation dense equality + +```agda +module foundation.double-negation-dense-equality where +``` + +
Imports + +```agda +open import foundation.action-on-identifications-functions +open import foundation.binary-relations +open import foundation.dependent-pair-types +open import foundation.double-negation +open import foundation.equality-dependent-pair-types +open import foundation.equivalences +open import foundation.retracts-of-types +open import foundation.transport-along-identifications +open import foundation.universe-levels + +open import foundation-core.equivalence-relations +open import foundation-core.identity-types +open import foundation-core.propositions +open import foundation-core.sets +``` + +
+ +## Idea + +A type `A` is said to have +{{#concept "double negation dense equality" Agda=has-double-negation-dense-equality}} +if for every two elements `x` and `y` in `A`, it is +[irrefutable](logic.irrefutable-types.md) that `x` and `y` are +[equal](foundation-core.identity-types.md). In other words, if all elements of +`A` are [irrefutably equal](foundation.irrefutable-equality.md). + +## Definitions + +### Types with double negation dense equality + +```agda +has-double-negation-dense-equality : {l : Level} → UU l → UU l +has-double-negation-dense-equality A = (x y : A) → irrefutable-eq x y +``` + +## Properties + +### If irrefutable equality maps into the identity type of `A`, then `A` is a set + +```agda +is-set-irrefutable-eq-in-id : + {l : Level} {A : UU l} → ((x y : A) → irrefutable-eq x y → x ＝ y) → is-set A +is-set-irrefutable-eq-in-id = + is-set-prop-in-id irrefutable-eq is-prop-irrefutable-eq refl-irrefutable-eq +``` + +### Retracts of types with double negation dense equality + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : UU l2} + where + + has-double-negation-dense-equality-retract-of : + B retract-of A → + has-double-negation-dense-equality A → + has-double-negation-dense-equality B + has-double-negation-dense-equality-retract-of (i , r , R) H x y = + map-double-negation (λ p → inv (R x) ∙ ap r p ∙ R y) (H (i x) (i y)) + + has-double-negation-dense-equality-equiv : + B ≃ A → + has-double-negation-dense-equality A → has-double-negation-dense-equality B + has-double-negation-dense-equality-equiv e = + has-double-negation-dense-equality-retract-of (retract-equiv e) + + has-double-negation-dense-equality-equiv' : + A ≃ B → + has-double-negation-dense-equality A → has-double-negation-dense-equality B + has-double-negation-dense-equality-equiv' e = + has-double-negation-dense-equality-retract-of (retract-inv-equiv e) +``` + +### Dependent sums of types with double negation dense equality + +```agda +module _ + {l1 l2 : Level} {A : UU l1} {B : A → UU l2} + (mA : has-double-negation-dense-equality A) + (mB : (x : A) → has-double-negation-dense-equality (B x)) + where + + has-double-negation-dense-equality-Σ : + has-double-negation-dense-equality (Σ A B) + has-double-negation-dense-equality-Σ x y = + extend-double-negation + ( λ p → + map-double-negation (eq-pair-Σ p) (mB (pr1 y) (tr B p (pr2 x)) (pr2 y))) + ( mA (pr1 x) (pr1 y)) +``` diff --git a/src/foundation/double-negation-images.lagda.md b/src/foundation/double-negation-images.lagda.md index 4077fa59ba..7fdda611c5 100644 --- a/src/foundation/double-negation-images.lagda.md +++ b/src/foundation/double-negation-images.lagda.md @@ -43,9 +43,49 @@ open import logic.double-negation-stable-embeddings The {{#concept "double negation image" Disambiguation="of a map" Agda=double-negation-im}} -of `f : A → B` is the essentially unique type that factorizes `f` as a -[double negation dense map](logic.double-negation-dense-maps.md) followed by a +of `f : A → B` is the essentially unique type that +[factorizes](orthogonal-factorization-systems.factorizations-of-maps.md) `f` as +a [double negation dense map](logic.double-negation-dense-maps.md) followed by a [double negation stable embedding](logic.double-negation-stable-embeddings.md). +I.e., the double negation image `im'f` of `f` fits into a commuting triangle + +```text + im'f + ∧ \ + l / \ r + / f ∨ + A -------------> B +``` + +such that `l` is double negation dense, i.e., its +[fibers](foundation-core.fibers-of-maps.md) are +[nonempty](foundation.double-negation.md), and `r` is a double negation stable +embedding, i.e., its fibers are [propositions](foundation-core.propositions.md) +and satisfy the property that if they are nonempty then they are inhabited. + +This factorization is unique in the sense that any other commuting triangle + +```text + X + ∧ \ + l'/ \ r' + / f ∨ + A ------------> B +``` + +is uniquely equivalent to the double negation image factorization in a coherent +manner. This is a direct consequence of the fact that double negation is a +modality, which is shown in +[`foundation.double-negation-modality`](foundation.double-negation-modality.md). + +The double negation image factorization is in one sense an approximation to the +[image factorization](foundation.images.md) which satisfies a restricted +universal property that only applies to +[negative statements](foundation-core.negation.md) and does not rely on the +existence of +[propositional truncations](foundation.propositional-truncations.md). On the +other hand, the double negation image inclusion `r` satisfies the additional +property of being double negation stable, compared to the image inclusion. ## Definitions @@ -234,8 +274,8 @@ abstract is-prop-double-negation-im = is-trunc-double-negation-im neg-two-𝕋 double-negation-im-Prop : - {l1 l2 : Level} (X : Prop l1) {A : UU l2} - (f : A → type-Prop X) → Prop (l1 ⊔ l2) + {l1 l2 : Level} (X : Prop l1) {A : UU l2} → + (A → type-Prop X) → Prop (l1 ⊔ l2) double-negation-im-Prop = double-negation-im-Truncated-Type neg-two-𝕋 ``` @@ -249,8 +289,8 @@ abstract is-set-double-negation-im = is-trunc-double-negation-im neg-one-𝕋 double-negation-im-Set : - {l1 l2 : Level} (X : Set l1) {A : UU l2} - (f : A → type-Set X) → Set (l1 ⊔ l2) + {l1 l2 : Level} (X : Set l1) {A : UU l2} → + (A → type-Set X) → Set (l1 ⊔ l2) double-negation-im-Set = double-negation-im-Truncated-Type neg-one-𝕋 ``` diff --git a/src/foundation/double-negation.lagda.md b/src/foundation/double-negation.lagda.md index 5ecc842912..75e99d2729 100644 --- a/src/foundation/double-negation.lagda.md +++ b/src/foundation/double-negation.lagda.md @@ -18,9 +18,11 @@ open import foundation-core.propositions
-## Definition +## Idea -We define double negation and triple negation +We define double negation and triple negation. + +## Definitions ```agda infix 25 ¬¬_ ¬¬¬_ diff --git a/src/foundation/irrefutable-equality.lagda.md b/src/foundation/irrefutable-equality.lagda.md index cfe37e3665..b0ee4aef01 100644 --- a/src/foundation/irrefutable-equality.lagda.md +++ b/src/foundation/irrefutable-equality.lagda.md @@ -31,8 +31,7 @@ Two elements `x` and `y` in a type are said to be {{#concept "irrefutably equal" Disambiguation="elements of a type" Agda=irrefutable-eq}} if there is an element of the [double negation](foundation.double-negation.md) of the [identity type](foundation-core.identity-types.md) between them, -`¬¬ (x ＝ y)`. If every two elements of a type are irrefutably equal, we say the -type _has double negation dense equality_. +`¬¬ (x ＝ y)`. ## Definitions @@ -99,12 +98,11 @@ abstract ```agda irrefutable-eq-equivalence-relation : {l1 : Level} (A : UU l1) → equivalence-relation l1 A -pr1 (irrefutable-eq-equivalence-relation A) = irrefutable-eq-Prop -pr1 (pr2 (irrefutable-eq-equivalence-relation A)) = refl-irrefutable-eq -pr1 (pr2 (pr2 (irrefutable-eq-equivalence-relation A))) = - symmetric-irrefutable-eq -pr2 (pr2 (pr2 (irrefutable-eq-equivalence-relation A))) = - transitive-irrefutable-eq +irrefutable-eq-equivalence-relation A = + ( irrefutable-eq-Prop , + refl-irrefutable-eq , + symmetric-irrefutable-eq , + transitive-irrefutable-eq) ``` ### If irrefutable equality maps into the identity type of `A`, then `A` is a set @@ -116,47 +114,7 @@ is-set-irrefutable-eq-in-id = is-set-prop-in-id irrefutable-eq is-prop-irrefutable-eq refl-irrefutable-eq ``` -### Retracts of types with double negation dense equality +## See also -```agda -module _ - {l1 l2 : Level} {A : UU l1} {B : UU l2} - where - - has-double-negation-dense-equality-retract-of : - B retract-of A → - has-double-negation-dense-equality A → - has-double-negation-dense-equality B - has-double-negation-dense-equality-retract-of (i , r , R) H x y = - map-double-negation (λ p → inv (R x) ∙ ap r p ∙ R y) (H (i x) (i y)) - - has-double-negation-dense-equality-equiv : - B ≃ A → - has-double-negation-dense-equality A → has-double-negation-dense-equality B - has-double-negation-dense-equality-equiv e = - has-double-negation-dense-equality-retract-of (retract-equiv e) - - has-double-negation-dense-equality-equiv' : - A ≃ B → - has-double-negation-dense-equality A → has-double-negation-dense-equality B - has-double-negation-dense-equality-equiv' e = - has-double-negation-dense-equality-retract-of (retract-inv-equiv e) -``` - -### Dependent sums of types with double negation dense equality - -```agda -module _ - {l1 l2 : Level} {A : UU l1} {B : A → UU l2} - (mA : has-double-negation-dense-equality A) - (mB : (x : A) → has-double-negation-dense-equality (B x)) - where - - has-double-negation-dense-equality-Σ : - has-double-negation-dense-equality (Σ A B) - has-double-negation-dense-equality-Σ x y = - extend-double-negation - ( λ p → - map-double-negation (eq-pair-Σ p) (mB (pr1 y) (tr B p (pr2 x)) (pr2 y))) - ( mA (pr1 x) (pr1 y)) -``` +- [_Double negation dense equality_](foundation.double-negation-dense-equality.md) + is the property that all elements of a type are irrefutably equal. diff --git a/src/foundation/mere-equality.lagda.md b/src/foundation/mere-equality.lagda.md index 39d7049b9b..344dd98393 100644 --- a/src/foundation/mere-equality.lagda.md +++ b/src/foundation/mere-equality.lagda.md @@ -31,8 +31,14 @@ open import foundation-core.sets ## Idea -Two elements in a type are said to be merely equal if there is an element of the -propositionally truncated identity type between them. +Two elements `x` and `y` in a type `A` are said to be +{{#concept "merely equal" Agda=mere-eq}} if there is an element of the +[propositionally truncated](foundation.propositional-truncations.md) +[identity type](foundation-core.identity-types.md) between them. + +```text + ║ x ＝ y ║₋₁ +``` ## Definitions @@ -96,10 +102,8 @@ abstract ```agda mere-eq-equivalence-relation : {l1 : Level} (A : UU l1) → equivalence-relation l1 A -pr1 (mere-eq-equivalence-relation A) = mere-eq-Prop -pr1 (pr2 (mere-eq-equivalence-relation A)) = refl-mere-eq -pr1 (pr2 (pr2 (mere-eq-equivalence-relation A))) = symmetric-mere-eq -pr2 (pr2 (pr2 (mere-eq-equivalence-relation A))) = transitive-mere-eq +mere-eq-equivalence-relation A = + ( mere-eq-Prop , refl-mere-eq , symmetric-mere-eq , transitive-mere-eq) ``` ### Any map into a set reflects mere equality @@ -133,7 +137,8 @@ is-set-mere-eq-in-id = ``` In other words, if equality on `A` has an -[ε-operator](foundation.hilberts-epsilon-operators.md), then `A` is a set. +[ε-operator](foundation.hilberts-epsilon-operators.md), or "split support", then +`A` is a set. ### Retracts of types with merely equal elements From c7fc63c37a03f3b14aa98cfe3b005a920a4b35ff Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Sun, 8 Jun 2025 10:02:27 +0100 Subject: [PATCH 17/20] Update src/foundation/inequality-booleans.lagda.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vojtěch Štěpančík --- src/foundation/inequality-booleans.lagda.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/foundation/inequality-booleans.lagda.md b/src/foundation/inequality-booleans.lagda.md index e49d787d4d..5de0eb559c 100644 --- a/src/foundation/inequality-booleans.lagda.md +++ b/src/foundation/inequality-booleans.lagda.md @@ -148,7 +148,7 @@ bool-Total-Order = (bool-Poset , is-total-leq-bool) bool-Decidable-Total-Order : Decidable-Total-Order lzero lzero bool-Decidable-Total-Order = ( bool-Poset , - ( is-total-leq-bool) , + is-total-leq-bool , ( λ x y → is-decidable-Decidable-Prop (leq-bool-Decidable-Prop x y))) ``` From 12c318af549930c61c133d61906e748ebfc91a67 Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Sun, 8 Jun 2025 10:02:50 +0100 Subject: [PATCH 18/20] Update src/foundation/mere-equality.lagda.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vojtěch Štěpančík --- src/foundation/mere-equality.lagda.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/foundation/mere-equality.lagda.md b/src/foundation/mere-equality.lagda.md index 344dd98393..279e8cbd94 100644 --- a/src/foundation/mere-equality.lagda.md +++ b/src/foundation/mere-equality.lagda.md @@ -57,7 +57,7 @@ module _ is-prop-mere-eq x y = is-prop-type-trunc-Prop ``` -### Types whose elements are merely equal +### Types whose elements are all merely equal ```agda all-elements-merely-equal : {l : Level} → UU l → UU l From 5b5eac3dbe3b6ebf22b4976da6fc471e917c1b1e Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Sun, 8 Jun 2025 10:09:14 +0100 Subject: [PATCH 19/20] Update src/logic/complements-decidable-subtypes.lagda.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vojtěch Štěpančík --- src/logic/complements-decidable-subtypes.lagda.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/logic/complements-decidable-subtypes.lagda.md b/src/logic/complements-decidable-subtypes.lagda.md index 5887b51c6d..44304ffbcd 100644 --- a/src/logic/complements-decidable-subtypes.lagda.md +++ b/src/logic/complements-decidable-subtypes.lagda.md @@ -121,16 +121,16 @@ module _ A ≃ type-decidable-subtype P + type-complement-decidable-subtype P equiv-coproduct-decomposition-decidable-subtype = equivalence-reasoning - A - ≃ Σ A (λ x → is-decidable (is-in-decidable-subtype P x)) - by + A + ≃ Σ A (λ x → is-decidable (is-in-decidable-subtype P x)) + by inv-right-unit-law-Σ-is-contr ( λ x → is-proof-irrelevant-is-prop ( is-prop-is-decidable (is-prop-is-in-decidable-subtype P x)) ( is-decidable-decidable-subtype P x)) - ≃ type-decidable-subtype P + type-complement-decidable-subtype P - by + ≃ type-decidable-subtype P + type-complement-decidable-subtype P + by left-distributive-Σ-coproduct A ( is-in-decidable-subtype P) ( is-in-complement-decidable-subtype P) From 9c1493290b04f819255739217498faa56f0e503b Mon Sep 17 00:00:00 2001 From: Fredrik Bakke Date: Mon, 16 Jun 2025 13:36:44 +0100 Subject: [PATCH 20/20] review --- src/foundation/decidable-type-families.lagda.md | 7 ++++--- src/foundation/inequality-booleans.lagda.md | 6 ++++-- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/foundation/decidable-type-families.lagda.md b/src/foundation/decidable-type-families.lagda.md index af47df982a..a27b81cccf 100644 --- a/src/foundation/decidable-type-families.lagda.md +++ b/src/foundation/decidable-type-families.lagda.md @@ -90,13 +90,14 @@ module _ where is-decidable-neg-decidable-family : - is-decidable-family (¬_ ∘ family-decidable-family P) + is-decidable-family (λ x → ¬ (family-decidable-family P x)) is-decidable-neg-decidable-family = is-decidable-neg ∘ is-decidable-decidable-family P neg-decidable-family : decidable-family l2 A neg-decidable-family = - ( ¬_ ∘ family-decidable-family P , is-decidable-neg-decidable-family) + ( ( λ x → ¬ (family-decidable-family P x)) , + is-decidable-neg-decidable-family) ``` ### Composition of decidable families @@ -142,7 +143,7 @@ module _ comp-decidable-family-decidable-subtype' : (P : decidable-family l2 A) → - ((x : A) → decidable-family l3 (family-decidable-family P x)) → + ( (x : A) → decidable-family l3 (family-decidable-family P x)) → ( (x : A) → has-double-negation-dense-equality (family-decidable-family P x)) → decidable-family (l2 ⊔ l3) A diff --git a/src/foundation/inequality-booleans.lagda.md b/src/foundation/inequality-booleans.lagda.md index 5de0eb559c..e26d2cd07c 100644 --- a/src/foundation/inequality-booleans.lagda.md +++ b/src/foundation/inequality-booleans.lagda.md @@ -33,8 +33,10 @@ open import order-theory.total-orders The {{#concept "standard inequality relation" Disambiguation="on booleans" Agda=leq-bool}} -on [booleans](foundation.booleans.md) is the inductively defined -[relation](foundation.binary-relations.md) given by the four inequalities +on [booleans](foundation.booleans.md) is the +[partial order](order-theory.posets.md) defined by the logical connective `⇒`, +i.e. `(x ≤ y) := (x ⇒ y)`. This means it is the unique partial order on the +booleans satisfying the four inequalities ```text false ≤ false