Documentation

Bdd.Nary

@[reducible, inline]
abbrev Nary.Func (n : ℕ) (α : Type u_1) (β : Sort u_2) :
Sort (imax (u_1 + 1) u_2)
Equations
Instances For
    def Nary.DependsOn {n : ℕ} {α : Type u_1} {β : Sort u_2} (f : Func n α β) (i : Fin n) :

    DependsOn f i if the output of f depends on the value of the ith input.

    Equations
    Instances For
      theorem Nary.dependsOn_iff {n : ℕ} {α : Type u_1} {β : Sort u_2} {f : Func n α β} {i : Fin n} :
      DependsOn f i ↔ ∃ (v1 : Vector α n), ∃ (v2 : Vector α n), (∀ (i' : Fin n), i' ≠ i → v1[i'] = v2[i']) ∧ f v1 ≠ f v2
      theorem Nary.push_pop_last {α : Type u_1} {n : ℕ} (I : Vector α (n + 1)) :
      I.pop.push I[n] = I
      theorem Nary.eq_of_forall_dependency_getElem_eq {n : ℕ} {α : Type u_1} {β : Sort u_2} {f : Func n α β} {I J : Vector α n} :
      (∀ (i : Fin n), DependsOn f i → I[i] = J[i]) → f I = f J
      def Nary.restrict {n : ℕ} {α : Type u_1} {β : Sort u_2} (f : Func n α β) :
      α → Fin n → Func n α β
      Equations
      Instances For
        @[simp]
        theorem Nary.restrict_const {n : ℕ} {α : Type u_1} {β : Sort u_2} {c : α} {b : β} {i : Fin n} :
        restrict (fun (x : Vector α n) => b) c i = fun (x : Vector α n) => b
        theorem Nary.restrict_if {n : ℕ} {α : Type u_1} {β : Sort u_2} {f g : Func n α β} {b : α} {i : Fin n} {c : Func n α Bool} :
        restrict (fun (I : Vector α n) => bif c I then f I else g I) b i = fun (I : Vector α n) => bif restrict c b i I then restrict f b i I else restrict g b i I