Documentation

Complexitylib.Algebraic.LowerBound.Cutwidth.MultiOutput.Restrict.Internal

Proofs for restricted splits #

The fibre bound of MultiOutput.Rank sums over all inputs. Its proof only mixes inputs with equal boundary keys, so it holds for any set Z of inputs closed under mixing (card_le_of_fibres_of_mix): the members of Z with a fixed key are a product of left and right parts, and the left parts embed into the left fibre of any member taken within Z. Coordinatewise products are closed under mixing (mix_mem_piFinset), and so is the slice of inputs agreeing with a base point z₀ off a set J of free coordinates (slice).

On a slice, if the function changes by g d when the input changes by d, a left fibre minus its base point consists of vectors supported on the free inputs placed in S whose image vanishes on the outputs carried outside S (card_inter_leftFibre_le). As the slice has |U| ^ |J| members (card_slice), this gives card_pow_le_supportedKernel. For a closed set both kernels must then be full, so g maps vectors supported on one side to vectors vanishing on the outputs of the other side (apply_eq_zero_of_closed).

The fibre bound on a set closed under mixing #

theorem Algebraic.Cutwidth.MultiOutput.Internal.card_leftParts_le_inter {σ : Signature} {n s m : ℕ} {U : Type u_1} [Fintype U] [DecidableEq U] (p : Program σ n s) (I : Interpretation σ U) (out : Fin m → Wire n s) (f : (Fin n → U) → Fin m → U) (hf : ∀ (x : Fin n → U) (i : Fin m), p.trace I x (out i) = f x i) (S : Finset (Wire n s)) {Z : Finset (Fin n → U)} (hZ : ∀ x ∈ Z, ∀ x' ∈ Z, SingleCut.mix S x x' ∈ Z) {x₀ : Fin n → U} (hx₀ : x₀ ∈ Z) :
(SingleCut.leftParts p I S Z (SingleCut.boundaryKey p I S x₀)).card ≤ (Z ∩ leftFibre out f S x₀).card

The left parts of a fibre within Z embed into the left fibre, within Z, of any of its members.

theorem Algebraic.Cutwidth.MultiOutput.Internal.card_rightParts_le_inter {σ : Signature} {n s m : ℕ} {U : Type u_1} [Fintype U] [DecidableEq U] (p : Program σ n s) (I : Interpretation σ U) (out : Fin m → Wire n s) (f : (Fin n → U) → Fin m → U) (hf : ∀ (x : Fin n → U) (i : Fin m), p.trace I x (out i) = f x i) (S : Finset (Wire n s)) {Z : Finset (Fin n → U)} (hZ : ∀ x ∈ Z, ∀ x' ∈ Z, SingleCut.mix S x x' ∈ Z) {x₀ : Fin n → U} (hx₀ : x₀ ∈ Z) :
(SingleCut.rightParts p I S Z (SingleCut.boundaryKey p I S x₀)).card ≤ (Z ∩ rightFibre out f S x₀).card

The right parts of a fibre within Z embed into the right fibre, within Z, of any of its members.

theorem Algebraic.Cutwidth.MultiOutput.Internal.card_le_of_fibres_of_mix {σ : Signature} {n s m : ℕ} {U : Type u_1} [Fintype U] [DecidableEq U] (p : Program σ n s) (I : Interpretation σ U) (out : Fin m → Wire n s) (f : (Fin n → U) → Fin m → U) (hf : ∀ (x : Fin n → U) (i : Fin m), p.trace I x (out i) = f x i) (S : Finset (Wire n s)) {Z : Finset (Fin n → U)} (hZ : ∀ x ∈ Z, ∀ x' ∈ Z, SingleCut.mix S x x' ∈ Z) {DT DS : ℕ} (hT : ∀ x ∈ Z, (Z ∩ leftFibre out f S x).card ≤ DT) (hS : ∀ x ∈ Z, (Z ∩ rightFibre out f S x).card ≤ DS) :

The fibre bound on a set closed under mixing. If Z is closed under mixing, every left fibre within Z has at most DT elements and every right fibre within Z at most DS, then |Z| ≤ |U| ^ (|A| + |B|) · DT · DS.

theorem Algebraic.Cutwidth.MultiOutput.Internal.mix_mem_piFinset {n s : ℕ} {U : Type u_1} (S : Finset (Wire n s)) (D : Fin n → Finset U) {x x' : Fin n → U} (hx : x ∈ Fintype.piFinset D) (hx' : x' ∈ Fintype.piFinset D) :

Coordinatewise products are closed under mixing.

Slices #

def Algebraic.Cutwidth.MultiOutput.Internal.slice {n : ℕ} {U : Type u_1} [Fintype U] [DecidableEq U] (J : Finset (Fin n)) (z₀ : Fin n → U) :
Finset (Fin n → U)

The inputs agreeing with z₀ on every coordinate outside J.

Equations
Instances For
    theorem Algebraic.Cutwidth.MultiOutput.Internal.mem_slice {n : ℕ} {U : Type u_1} [Fintype U] [DecidableEq U] {J : Finset (Fin n)} {z₀ z : Fin n → U} :
    z ∈ slice J z₀ ↔ ∀ k ∉ J, z k = z₀ k
    theorem Algebraic.Cutwidth.MultiOutput.Internal.card_slice {n : ℕ} {U : Type u_1} [Fintype U] [DecidableEq U] (J : Finset (Fin n)) (z₀ : Fin n → U) :
    (slice J z₀).card = Fintype.card U ^ J.card

    A slice has |U| ^ |J| members.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.mix_mem_slice {n : ℕ} {U : Type u_1} [Fintype U] [DecidableEq U] {s : ℕ} (S : Finset (Wire n s)) {J : Finset (Fin n)} {z₀ x x' : Fin n → U} (hx : x ∈ slice J z₀) (hx' : x' ∈ slice J z₀) :
    SingleCut.mix S x x' ∈ slice J z₀

    Slices are closed under mixing.

    The two sides of a split partition the free coordinates.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.slice_subset_slice {n : ℕ} {U : Type u_1} [Fintype U] [DecidableEq U] {J₁ J₂ : Finset (Fin n)} (hJ : J₁ ⊆ J₂) (z₀ : Fin n → U) :
    slice J₁ z₀ ⊆ slice J₂ z₀

    Monotonicity of slices in the set of free coordinates.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.card_pow_inter_le_forward_of_leftFibre {σ : Signature} {n s m : ℕ} {U : Type u_1} [Fintype U] [DecidableEq U] (p : Program σ n s) (I : Interpretation σ U) (out : Fin m → Wire n s) (f : (Fin n → U) → Fin m → U) (hf : ∀ (x : Fin n → U) (i : Fin m), p.trace I x (out i) = f x i) (S : Finset (Wire n s)) (J : Finset (Fin n)) (z₀ : Fin n → U) {DT : ℕ} (hT : ∀ x ∈ slice J z₀, (slice J z₀ ∩ leftFibre out f S x).card ≤ DT) :

    One-sided forward fibre bound on a slice. On the slice of inputs agreeing with z₀ outside J, if every left fibre within slice J z₀ has at most DT elements, then |U| ^ |inputsIn S ∩ J| ≤ |U| ^ |forward p S| · DT.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.card_pow_compl_inter_le_backward_of_rightFibre {σ : Signature} {n s m : ℕ} {U : Type u_1} [Fintype U] [DecidableEq U] (p : Program σ n s) (I : Interpretation σ U) (out : Fin m → Wire n s) (f : (Fin n → U) → Fin m → U) (hf : ∀ (x : Fin n → U) (i : Fin m), p.trace I x (out i) = f x i) (S : Finset (Wire n s)) (J : Finset (Fin n)) (z₀ : Fin n → U) {DS : ℕ} (hS : ∀ x ∈ slice J z₀, (slice J z₀ ∩ rightFibre out f S x).card ≤ DS) :

    One-sided backward fibre bound on a slice. On the slice of inputs agreeing with z₀ outside J, if every right fibre within slice J z₀ has at most DS elements, then |U| ^ |(inputsIn S)ᶜ ∩ J| ≤ |U| ^ |backward p S| · DS.

    Kernels on a slice #

    theorem Algebraic.Cutwidth.MultiOutput.Internal.supportedKernel_subset_slice {n m : ℕ} {U : Type u_1} [AddCommGroup U] [Fintype U] [DecidableEq U] (g : (Fin n → U) → Fin m → U) (P : Finset (Fin n)) (Q : Finset (Fin m)) :
    supportedKernel g P Q ⊆ slice P 0

    Kernel vectors are supported vectors, so there are at most |U| ^ |P| of them.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.card_supportedKernel_le {n m : ℕ} {U : Type u_1} [AddCommGroup U] [Fintype U] [DecidableEq U] (g : (Fin n → U) → Fin m → U) (P : Finset (Fin n)) (Q : Finset (Fin m)) :
    theorem Algebraic.Cutwidth.MultiOutput.Internal.card_supportedKernel_lt {n m : ℕ} {U : Type u_1} [AddCommGroup U] [Fintype U] [DecidableEq U] (g : (Fin n → U) → Fin m → U) {P : Finset (Fin n)} {Q : Finset (Fin m)} {d : Fin n → U} (hd : ∀ k ∉ P, d k = 0) {i : Fin m} (hi : i ∈ Q) (hgd : g d i ≠ 0) :

    A supported vector whose image does not vanish on Q leaves the kernel short.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.card_inter_leftFibre_le {n s m : ℕ} {U : Type u_1} [AddCommGroup U] [Fintype U] [DecidableEq U] {out : Fin m → Wire n s} {f : (Fin n → U) → Fin m → U} {S : Finset (Wire n s)} {J : Finset (Fin n)} {z₀ : Fin n → U} {g : (Fin n → U) → Fin m → U} (hg : ∀ z ∈ slice J z₀, ∀ z' ∈ slice J z₀, f z' - f z = g (z' - z)) {x : Fin n → U} (hx : x ∈ slice J z₀) :

    Left fibres on a slice. Subtracting the base point maps a left fibre within the slice injectively into the vectors supported on the free inputs in S whose image vanishes on the outputs carried outside S.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.card_inter_rightFibre_le {n s m : ℕ} {U : Type u_1} [AddCommGroup U] [Fintype U] [DecidableEq U] {out : Fin m → Wire n s} {f : (Fin n → U) → Fin m → U} {S : Finset (Wire n s)} {J : Finset (Fin n)} {z₀ : Fin n → U} {g : (Fin n → U) → Fin m → U} (hg : ∀ z ∈ slice J z₀, ∀ z' ∈ slice J z₀, f z' - f z = g (z' - z)) {x : Fin n → U} (hx : x ∈ slice J z₀) :

    Right fibres on a slice.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.card_pow_le_supportedKernel_forward {σ : Signature} {n s m : ℕ} {U : Type u_1} [AddCommGroup U] [Fintype U] [DecidableEq U] (p : Program σ n s) (out : Fin m → Wire n s) (f : (Fin n → U) → Fin m → U) (I : Interpretation σ U) (hf : ∀ (x : Fin n → U) (i : Fin m), p.trace I x (out i) = f x i) (S : Finset (Wire n s)) (J : Finset (Fin n)) (z₀ : Fin n → U) (g : (Fin n → U) → Fin m → U) (hg : ∀ (z z' : Fin n → U), (∀ k ∉ J, z k = z₀ k) → (∀ k ∉ J, z' k = z₀ k) → f z' - f z = g (z' - z)) :

    The one-sided forward kernel bound on a slice. If the wires out carry f, and on the slice of inputs agreeing with z₀ off J the function changes by g d when its input changes by d, then every split S satisfies |U| ^ |inputsIn S ∩ J| ≤ |U| ^ |forward p S| · |supportedKernel g (inputsIn S ∩ J) Y_T|.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.card_pow_le_supportedKernel_backward {σ : Signature} {n s m : ℕ} {U : Type u_1} [AddCommGroup U] [Fintype U] [DecidableEq U] (p : Program σ n s) (out : Fin m → Wire n s) (f : (Fin n → U) → Fin m → U) (I : Interpretation σ U) (hf : ∀ (x : Fin n → U) (i : Fin m), p.trace I x (out i) = f x i) (S : Finset (Wire n s)) (J : Finset (Fin n)) (z₀ : Fin n → U) (g : (Fin n → U) → Fin m → U) (hg : ∀ (z z' : Fin n → U), (∀ k ∉ J, z k = z₀ k) → (∀ k ∉ J, z' k = z₀ k) → f z' - f z = g (z' - z)) :

    The one-sided backward kernel bound on a slice. Symmetrically, |U| ^ |(inputsIn S)ᶜ ∩ J| ≤ |U| ^ |backward p S| · |supportedKernel g ((inputsIn S)ᶜ ∩ J) Y_S|.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.card_pow_le_supportedKernel {σ : Signature} {n s m : ℕ} {U : Type u_1} [AddCommGroup U] [Fintype U] [DecidableEq U] (p : Program σ n s) (out : Fin m → Wire n s) (f : (Fin n → U) → Fin m → U) (I : Interpretation σ U) (hf : ∀ (x : Fin n → U) (i : Fin m), p.trace I x (out i) = f x i) (S : Finset (Wire n s)) (J : Finset (Fin n)) (z₀ : Fin n → U) (g : (Fin n → U) → Fin m → U) (hg : ∀ (z z' : Fin n → U), (∀ k ∉ J, z k = z₀ k) → (∀ k ∉ J, z' k = z₀ k) → f z' - f z = g (z' - z)) :

    The kernel form of the restricted rank-cut bound. If the wires out carry f, and on the slice of inputs agreeing with z₀ off J the function changes by g d when its input changes by d, then every split satisfies |U| ^ |J| ≤ |U| ^ (|A| + |B|) · |ker₁| · |ker₂|, where ker₁ consists of the vectors supported on the free inputs in S whose image vanishes on the outputs outside S, and ker₂ symmetrically.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.apply_eq_zero_of_forward_eq_empty {σ : Signature} {n s m : ℕ} {U : Type u_1} [AddCommGroup U] (p : Program σ n s) (out : Fin m → Wire n s) (f : (Fin n → U) → Fin m → U) (I : Interpretation σ U) (hf : ∀ (x : Fin n → U) (i : Fin m), p.trace I x (out i) = f x i) (S : Finset (Wire n s)) (J : Finset (Fin n)) (z₀ : Fin n → U) (g : (Fin n → U) → Fin m → U) (hg : ∀ (z z' : Fin n → U), (∀ k ∉ J, z k = z₀ k) → (∀ k ∉ J, z' k = z₀ k) → f z' - f z = g (z' - z)) (hfwd : SingleCut.forward p S = ∅) {d : Fin n → U} (hd : ∀ k ∉ SingleCut.inputsIn S ∩ J, d k = 0) {i : Fin m} (hi : i ∉ outputsIn out S) :
    g d i = 0

    No forward signals separate. If forward p S = ∅, then g maps vectors supported on the free inputs in S to vectors vanishing on the outputs carried outside S.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.apply_eq_zero_of_backward_eq_empty {σ : Signature} {n s m : ℕ} {U : Type u_1} [AddCommGroup U] (p : Program σ n s) (out : Fin m → Wire n s) (f : (Fin n → U) → Fin m → U) (I : Interpretation σ U) (hf : ∀ (x : Fin n → U) (i : Fin m), p.trace I x (out i) = f x i) (S : Finset (Wire n s)) (J : Finset (Fin n)) (z₀ : Fin n → U) (g : (Fin n → U) → Fin m → U) (hg : ∀ (z z' : Fin n → U), (∀ k ∉ J, z k = z₀ k) → (∀ k ∉ J, z' k = z₀ k) → f z' - f z = g (z' - z)) (hbwd : SingleCut.backward p S = ∅) {d : Fin n → U} (hd : ∀ k ∉ (SingleCut.inputsIn S)ᶜ ∩ J, d k = 0) {i : Fin m} (hi : i ∈ outputsIn out S) :
    g d i = 0

    No backward signals separate. If backward p S = ∅, then g maps vectors supported on the free inputs outside S to vectors vanishing on the outputs carried in S.

    theorem Algebraic.Cutwidth.MultiOutput.Internal.apply_eq_zero_of_closed {σ : Signature} {n s m : ℕ} {U : Type u_1} [AddCommGroup U] (p : Program σ n s) (out : Fin m → Wire n s) (f : (Fin n → U) → Fin m → U) (I : Interpretation σ U) (hf : ∀ (x : Fin n → U) (i : Fin m), p.trace I x (out i) = f x i) (S : Finset (Wire n s)) (J : Finset (Fin n)) (z₀ : Fin n → U) (g : (Fin n → U) → Fin m → U) (hg : ∀ (z z' : Fin n → U), (∀ k ∉ J, z k = z₀ k) → (∀ k ∉ J, z' k = z₀ k) → f z' - f z = g (z' - z)) (hfwd : SingleCut.forward p S = ∅) (hbwd : SingleCut.backward p S = ∅) :
    (∀ (d : Fin n → U), (∀ k ∉ SingleCut.inputsIn S ∩ J, d k = 0) → ∀ i ∉ outputsIn out S, g d i = 0) ∧ ∀ (d : Fin n → U), (∀ k ∉ (SingleCut.inputsIn S)ᶜ ∩ J, d k = 0) → ∀ i ∈ outputsIn out S, g d i = 0

    Closed sets separate. If a split has no forward and no backward signals, then g maps vectors supported on the free inputs in S to vectors vanishing on the outputs carried outside S, and vectors supported on the free inputs outside S to vectors vanishing on the outputs carried in S.