Documentation

Strips.VarSet

Sets of Variables #

This file implements set of variables with the aim to be both easy to work with and effient at runtime.

Sets of variables #

structure STRIPS.VarSet (n : ℕ) :

A set of variables of type Fin n, where n is the number of variables

  • toBitVec : BitVec n

    The bitvector internally representing the set of variables.

Instances For
    def STRIPS.instDecidableEqVarSet.decEq {n✝ : ℕ} (x✝ x✝¹ : VarSet n✝) :
    Decidable (x✝ = x✝¹)
    Equations
    Instances For
      @[instance_reducible]
      Equations
      theorem STRIPS.VarSet.mem_iff {n : ℕ} {i : Fin n} {V : VarSet n} :
      @[instance_reducible]
      instance STRIPS.VarSet.instDecidableMemFin {n : ℕ} {i : Fin n} {V : VarSet n} :
      Equations
      @[reducible]
      Equations
      @[instance_reducible]
      instance STRIPS.VarSet.instDecidableSubset {n : ℕ} {V V' : VarSet n} :
      Decidable (V ⊆ V')
      Equations
      theorem STRIPS.VarSet.ext {n : ℕ} {V V' : VarSet n} :
      (∀ (i : Fin n), i ∈ V ↔ i ∈ V') → V = V'
      theorem STRIPS.VarSet.ext_iff {n : ℕ} {V V' : VarSet n} :
      V = V' ↔ ∀ (i : Fin n), i ∈ V ↔ i ∈ V'
      theorem STRIPS.VarSet.subset_iff {n : ℕ} {V V' : VarSet n} :
      V ⊆ V' ↔ ∀ (i : Fin n), i ∈ V → i ∈ V'
      @[instance_reducible]
      Equations
      @[simp]
      theorem STRIPS.VarSet.mem_empty {n : ℕ} {i : Fin n} :
      def STRIPS.VarSet.insert {n : ℕ} (i : Fin n) (V : VarSet n) :

      Return the VarSet containing all variables in V and the variable i.

      Equations
      Instances For
        @[simp]
        theorem STRIPS.VarSet.mem_insert {n : ℕ} {V : VarSet n} {i j : Fin n} :
        j ∈ insert i V ↔ j ∈ V ∨ j = i
        def STRIPS.VarSet.erase {n : ℕ} (i : Fin n) (V : VarSet n) :

        Return the VarSet containing all variables in V except the variable i.

        Equations
        Instances For
          @[simp]
          theorem STRIPS.VarSet.mem_erase {n : ℕ} {V : VarSet n} {i j : Fin n} :
          j ∈ erase i V ↔ j ∈ V ∧ j ≠ i

          Return the VarSet containing all variables.

          Equations
          Instances For
            @[simp]
            theorem STRIPS.VarSet.mem_all {n : ℕ} {i : Fin n} :
            def STRIPS.VarSet.ofFn {n : ℕ} (f : Fin n → Bool) :

            Return the VarSet containing all variables i for which f i is true.

            Equations
            Instances For
              @[simp]
              theorem STRIPS.VarSet.mem_ofFn {n : ℕ} {f : Fin n → Bool} {i : Fin n} :
              i ∈ ofFn f ↔ f i = true
              @[instance_reducible]
              Equations
              @[simp]
              theorem STRIPS.VarSet.mem_union {n : ℕ} {V V' : VarSet n} {i : Fin n} :
              i ∈ V ∪ V' ↔ i ∈ V ∨ i ∈ V'
              @[simp]
              theorem STRIPS.VarSet.empty_union {n : ℕ} {V : VarSet n} :
              ∅ ∪ V = V
              @[simp]
              theorem STRIPS.VarSet.union_empty {n : ℕ} {V : VarSet n} :
              V ∪ ∅ = V
              theorem STRIPS.VarSet.union_comm {n : ℕ} {V1 V2 : VarSet n} :
              V1 ∪ V2 = V2 ∪ V1
              @[simp]
              theorem STRIPS.VarSet.union_assoc {n : ℕ} {V1 V2 V3 : VarSet n} :
              V1 ∪ V2 ∪ V3 = V1 ∪ (V2 ∪ V3)
              @[instance_reducible]
              Equations
              @[simp]
              theorem STRIPS.VarSet.mem_inter {n : ℕ} {V V' : VarSet n} {i : Fin n} :
              i ∈ V ∩ V' ↔ i ∈ V ∧ i ∈ V'
              @[simp]
              theorem STRIPS.VarSet.empty_inter {n : ℕ} {V : VarSet n} :
              theorem STRIPS.VarSet.inter_comm {n : ℕ} {V1 V2 : VarSet n} :
              V1 ∩ V2 = V2 ∩ V1
              @[simp]
              theorem STRIPS.VarSet.inter_assoc {n : ℕ} {V1 V2 V3 : VarSet n} :
              V1 ∩ V2 ∩ V3 = V1 ∩ (V2 ∩ V3)
              @[simp]
              theorem STRIPS.VarSet.inter_eq_empty_iff {n : ℕ} {V V' : VarSet n} :
              V ∩ V' = ∅ ↔ ∀ (i : Fin n), i ∈ V → ¬i ∈ V'
              @[instance_reducible]
              Equations
              @[simp]
              theorem STRIPS.VarSet.mem_compl {n : ℕ} {V : VarSet n} {i : Fin n} :
              i ∈ Vᶜ ↔ ¬i ∈ V
              @[instance_reducible]
              Equations
              @[simp]
              theorem STRIPS.VarSet.mem_diff {n : ℕ} {V V' : VarSet n} {i : Fin n} :
              i ∈ V \ V' ↔ i ∈ V ∧ ¬i ∈ V'
              def STRIPS.VarSet.foldl {α : Sort u_1} {n : ℕ} (f : α → Fin n → α) (init : α) (V : VarSet n) :
              α

              Folds a function over all variables in V with starting value init. The variables are combined in increasing order.

              Equations
              Instances For
                theorem STRIPS.VarSet.foldl_induction {α : Sort u_1} {n : ℕ} {V : VarSet n} (motive : ℕ → α → Prop) {f : α → Fin n → α} {init : α} (hinit : motive 0 init) (hmem : ∀ (a : α) (i : Fin n), i ∈ V → motive (↑i) a → motive (↑i + 1) (f a i)) (hnmem : ∀ (a : α) (i : Fin n), ¬i ∈ V → motive (↑i) a → motive (↑i + 1) a) :
                motive n (foldl f init V)
                theorem STRIPS.VarSet.foldl_cons {α : Type u_1} {n : ℕ} {V : VarSet n} {f : Fin n → α} {a : α} {as : List α} :
                a ∈ foldl (fun (a : List α) (i : Fin n) => f i :: a) as V ↔ (∃ (i : Fin n), i ∈ V ∧ a = f i) ∨ a ∈ as
                def STRIPS.VarSet.map {n m : ℕ} (V : VarSet n) (f : Fin n → Fin m) :

                Return the VarSet containing the variables f i for every variable i in V.

                Equations
                Instances For
                  theorem STRIPS.VarSet.mem_map {n m : ℕ} {V : VarSet n} {f : Fin n → Fin m} {i : Fin m} :
                  i ∈ V.map f ↔ ∃ (j : Fin n), j ∈ V ∧ i = f j
                  def STRIPS.VarSet.ofList {n : ℕ} (l : List (Fin n)) :

                  Return the VarSet containing all variables in the given list.

                  Equations
                  Instances For
                    @[simp]
                    theorem STRIPS.VarSet.ofList_cons {n : ℕ} {l : List (Fin n)} {i : Fin n} :
                    ofList (i :: l) = insert i (ofList l)
                    @[simp]
                    theorem STRIPS.VarSet.mem_ofList {n : ℕ} {l : List (Fin n)} {i : Fin n} :
                    i ∈ ofList l ↔ i ∈ l
                    def STRIPS.VarSet.toList {n : ℕ} (V : VarSet n) :
                    List (Fin n)

                    The list containing all variables in the given VarSet, in no particular order.

                    Equations
                    Instances For
                      @[simp]
                      theorem STRIPS.VarSet.mem_toList {n : ℕ} {V : VarSet n} (i : Fin n) :
                      i ∈ V.toList ↔ i ∈ V
                      @[simp]
                      @[instance_reducible]
                      Equations
                      • One or more equations did not get rendered due to their size.
                      @[instance_reducible]
                      Equations