ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SimpleGraph.adjMatrix_mul_apply
@[simp]
theorem adjMatrix_mul_apply [NonAssocSemiring α] (M : Matrix V V α) (v w : V) :
    (G.adjMatrix α * M) v w = ∑ u ∈ G.neighborFinset v, M u w 
Arguments: {V : Type u_1} {α : Type u_2} (G : SimpleGraph V) [DecidableRel G.Adj] [Fintype V] [NonAssocSemiring α] (M : Matrix V V α) (v w : V)
Goal: (SimpleGraph.adjMatrix α G * M) v w = ∑ u ∈ G.neighborFinset v, M u w
-- SimpleGraph.mul_adjMatrix_apply
@[simp]
theorem mul_adjMatrix_apply [NonAssocSemiring α] (M : Matrix V V α) (v w : V) :
    (M * G.adjMatrix α) v w = ∑ u ∈ G.neighborFinset w, M v u 
Arguments: {V : Type u_1} {α : Type u_2} (G : SimpleGraph V) [DecidableRel G.Adj] [Fintype V] [NonAssocSemiring α] (M : Matrix V V α) (v w : V)
Goal: (M * SimpleGraph.adjMatrix α G) v w = ∑ u ∈ G.neighborFinset w, M v u
-- SimpleGraph.trace_adjMatrix
@[simp]
theorem trace_adjMatrix [AddCommMonoid α] [One α] : Matrix.trace (G.adjMatrix α) = 0 
Arguments: {V : Type u_1} (α : Type u_2) (G : SimpleGraph V) [DecidableRel G.Adj] [Fintype V] [AddCommMonoid α] [One α]
Goal: (SimpleGraph.adjMatrix α G).trace = 0
-- SimpleGraph.adjMatrix_mul_self_apply_self
theorem adjMatrix_mul_self_apply_self [NonAssocSemiring α] (i : V) :
    (G.adjMatrix α * G.adjMatrix α) i i = degree G i 
Arguments: {V : Type u_1} {α : Type u_2} (G : SimpleGraph V) [DecidableRel G.Adj] [Fintype V] [NonAssocSemiring α] (i : V)
Goal: (SimpleGraph.adjMatrix α G * SimpleGraph.adjMatrix α G) i i = ↑(G.degree i)
-- SimpleGraph.adjMatrix_mulVec_const_apply
theorem adjMatrix_mulVec_const_apply [NonAssocSemiring α] {a : α} {v : V} :
    (G.adjMatrix α *ᵥ Function.const _ a) v = G.degree v * a 
Arguments: {V : Type u_1} {α : Type u_2} {G : SimpleGraph V} [DecidableRel G.Adj] [Fintype V] [NonAssocSemiring α] {a : α} {v : V}
Goal: (SimpleGraph.adjMatrix α G *ᵥ Function.const V a) v = ↑(G.degree v) * a
-- SimpleGraph.adjMatrix_mulVec_const_apply_of_regular
theorem adjMatrix_mulVec_const_apply_of_regular [NonAssocSemiring α] {d : ℕ} {a : α}
    (hd : G.IsRegularOfDegree d) {v : V} : (G.adjMatrix α *ᵥ Function.const _ a) v = d * a 
Arguments: {V : Type u_1} {α : Type u_2} {G : SimpleGraph V} [DecidableRel G.Adj] [Fintype V] [NonAssocSemiring α] {d : ℕ} {a : α} (hd : G.IsRegularOfDegree d) {v : V}
Goal: (SimpleGraph.adjMatrix α G *ᵥ Function.const V a) v = ↑d * a
-- SimpleGraph.adjMatrix_pow_apply_eq_card_walk
theorem adjMatrix_pow_apply_eq_card_walk [DecidableEq V] [Semiring α] (n : ℕ) (u v : V) :
    (G.adjMatrix α ^ n) u v = Fintype.card { p : G.Walk u v | p.length = n } 
Arguments: {V : Type u_1} {α : Type u_2} {G : SimpleGraph V} [DecidableRel G.Adj] [Fintype V] [DecidableEq V] [Semiring α] (n : ℕ) (u v : V)
Goal: (SimpleGraph.adjMatrix α G ^ n) u v = ↑(Fintype.card ↑{p | p.length = n})
-- SimpleGraph.one_add_adjMatrix_add_compl_adjMatrix_eq_allOnes
theorem one_add_adjMatrix_add_compl_adjMatrix_eq_allOnes [DecidableEq V] [DecidableEq α]
    [NonAssocSemiring α] : 1 + G.adjMatrix α + (G.adjMatrix α).compl = Matrix.of fun _ _ ↦ 1 
Arguments: {V : Type u_1} {α : Type u_2} {G : SimpleGraph V} [DecidableRel G.Adj] [DecidableEq V] [DecidableEq α] [NonAssocSemiring α]
Goal: 1 + SimpleGraph.adjMatrix α G + (SimpleGraph.adjMatrix α G).compl = Matrix.of fun x x => 1
-- SimpleGraph.dotProduct_mulVec_adjMatrix
theorem dotProduct_mulVec_adjMatrix [NonAssocSemiring α] (x y : V → α) :
    x ⬝ᵥ (G.adjMatrix α).mulVec y = ∑ i : V, ∑ j : V, if G.Adj i j then x i * y j else 0 
Arguments: {V : Type u_1} {α : Type u_2} {G : SimpleGraph V} [DecidableRel G.Adj] [Fintype V] [NonAssocSemiring α] (x y : V → α)
Goal: x ⬝ᵥ SimpleGraph.adjMatrix α G *ᵥ y = ∑ i : V, ∑ j : V, if G.Adj i j then x i * y j else 0
-- Matrix.IsAdjMatrix.adjMatrix_toGraph_eq
theorem adjMatrix_toGraph_eq [DecidableEq α] : h.toGraph.adjMatrix α = A 
Arguments: {V : Type u_1} {α : Type u_2} [MulZeroOneClass α] [Nontrivial α] {A : Matrix V V α} (h : A.IsAdjMatrix) [DecidableEq α]
Goal: SimpleGraph.adjMatrix α h.toGraph = A
-- Finpartition.energy_nonneg
theorem energy_nonneg : 0 ≤ P.energy G 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} (P : Finpartition s) (G : SimpleGraph α) [DecidableRel G.Adj]
Goal: 0 ≤ P.energy G
-- Finpartition.energy_le_one
theorem energy_le_one : P.energy G ≤ 1 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} (P : Finpartition s) (G : SimpleGraph α) [DecidableRel G.Adj]
Goal: P.energy G ≤ 1
-- Finpartition.coe_energy
@[simp, norm_cast]
theorem coe_energy {𝕜 : Type*} [LinearOrderedField 𝕜] : (P.energy G : 𝕜) =
    (∑ uv ∈ P.parts.offDiag, (G.edgeDensity uv.1 uv.2 : 𝕜) ^ 2) / (P.parts.card : 𝕜) ^ 2 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} (P : Finpartition s) (G : SimpleGraph α) [DecidableRel G.Adj] {𝕜 : Type u_2} [LinearOrderedField 𝕜]
Goal: ↑(P.energy G) = (∑ uv ∈ P.parts.offDiag, ↑(G.edgeDensity uv.1 uv.2) ^ 2) / ↑P.parts.card ^ 2
-- Composition.blocks_sum
@[ext]
structure Composition (n : ℕ) where
    blocks : List ℕ
    blocks_pos : ∀ {i}, i ∈ blocks → 0 < i
    blocks_sum : blocks.sum = n
Arguments: {n : ℕ} (self : Composition n)
Goal: self.blocks.sum = n
-- Composition.blocks_pos
@[ext]
structure Composition (n : ℕ) where
    blocks : List ℕ
    blocks_pos : ∀ {i}, i ∈ blocks → 0 < i
    blocks_sum : blocks.sum = n
Arguments: {n : ℕ} (self : Composition n) {i : ℕ}
Goal: i ∈ self.blocks → 0 < i
-- CompositionAsSet.getLast_mem
@[ext]
structure CompositionAsSet (n : ℕ) where
    boundaries : Finset (Fin n.succ)
    zero_mem : (0 : Fin n.succ) ∈ boundaries
    getLast_mem : Fin.last n ∈ boundaries
Arguments: {n : ℕ} (self : CompositionAsSet n)
Goal: Fin.last n ∈ self.boundaries
-- CompositionAsSet.zero_mem
@[ext]
structure CompositionAsSet (n : ℕ) where
    boundaries : Finset (Fin n.succ)
    zero_mem : (0 : Fin n.succ) ∈ boundaries
    getLast_mem : Fin.last n ∈ boundaries
Arguments: {n : ℕ} (self : CompositionAsSet n)
Goal: 0 ∈ self.boundaries
-- Composition.blocks_length
theorem blocks_length : c.blocks.length = c.length 
Arguments: {n : ℕ} (c : Composition n)
Goal: c.blocks.length = c.length
-- Composition.ofFn_blocksFun
theorem ofFn_blocksFun : ofFn c.blocksFun = c.blocks 
Arguments: {n : ℕ} (c : Composition n)
Goal: List.ofFn c.blocksFun = c.blocks
-- Composition.sum_blocksFun
theorem sum_blocksFun : ∑ i, c.blocksFun i = n 
Arguments: {n : ℕ} (c : Composition n)
Goal: ∑ i : Fin c.length, c.blocksFun i = n
-- Composition.blocksFun_mem_blocks
theorem blocksFun_mem_blocks (i : Fin c.length) : c.blocksFun i ∈ c.blocks 
Arguments: {n : ℕ} (c : Composition n) (i : Fin c.length)
Goal: c.blocksFun i ∈ c.blocks
-- Composition.one_le_blocks
@[simp]
theorem one_le_blocks {i : ℕ} (h : i ∈ c.blocks) : 1 ≤ i 
Arguments: {n : ℕ} (c : Composition n) {i : ℕ} (h : i ∈ c.blocks)
Goal: 1 ≤ i
-- Composition.one_le_blocks'
@[simp]
theorem one_le_blocks' {i : ℕ} (h : i < c.length) : 1 ≤ c.blocks[i] 
Arguments: {n : ℕ} (c : Composition n) {i : ℕ} (h : i < c.length)
Goal: 1 ≤ c.blocks[i]
-- Composition.blocks_pos'
@[simp]
theorem blocks_pos' (i : ℕ) (h : i < c.length) : 0 < c.blocks[i] 
Arguments: {n : ℕ} (c : Composition n) (i : ℕ) (h : i < c.length)
Goal: 0 < c.blocks[i]
-- Composition.one_le_blocksFun
theorem one_le_blocksFun (i : Fin c.length) : 1 ≤ c.blocksFun i 
Arguments: {n : ℕ} (c : Composition n) (i : Fin c.length)
Goal: 1 ≤ c.blocksFun i
-- Composition.length_le
theorem length_le : c.length ≤ n 
Arguments: {n : ℕ} (c : Composition n)
Goal: c.length ≤ n
-- Composition.length_pos_of_pos
theorem length_pos_of_pos (h : 0 < n) : 0 < c.length 
Arguments: {n : ℕ} (c : Composition n) (h : 0 < n)
Goal: 0 < c.length
-- Composition.sizeUpTo_zero
@[simp]
theorem sizeUpTo_zero : c.sizeUpTo 0 = 0 
Arguments: {n : ℕ} (c : Composition n)
Goal: c.sizeUpTo 0 = 0
-- Composition.sizeUpTo_ofLength_le
theorem sizeUpTo_ofLength_le (i : ℕ) (h : c.length ≤ i) : c.sizeUpTo i = n 
Arguments: {n : ℕ} (c : Composition n) (i : ℕ) (h : c.length ≤ i)
Goal: c.sizeUpTo i = n
-- Composition.sizeUpTo_length
@[simp]
theorem sizeUpTo_length : c.sizeUpTo c.length = n 
Arguments: {n : ℕ} (c : Composition n)
Goal: c.sizeUpTo c.length = n
-- Composition.sizeUpTo_le
theorem sizeUpTo_le (i : ℕ) : c.sizeUpTo i ≤ n 
Arguments: {n : ℕ} (c : Composition n) (i : ℕ)
Goal: c.sizeUpTo i ≤ n
-- Composition.sizeUpTo_succ
theorem sizeUpTo_succ {i : ℕ} (h : i < c.length) :
    c.sizeUpTo (i + 1) = c.sizeUpTo i + c.blocks[i] 
Arguments: {n : ℕ} (c : Composition n) {i : ℕ} (h : i < c.length)
Goal: c.sizeUpTo (i + 1) = c.sizeUpTo i + c.blocks[i]
-- Composition.sizeUpTo_succ'
theorem sizeUpTo_succ' (i : Fin c.length) :
    c.sizeUpTo ((i : ℕ) + 1) = c.sizeUpTo i + c.blocksFun i 
Arguments: {n : ℕ} (c : Composition n) (i : Fin c.length)
Goal: c.sizeUpTo (↑i + 1) = c.sizeUpTo ↑i + c.blocksFun i
-- Composition.sizeUpTo_strict_mono
theorem sizeUpTo_strict_mono {i : ℕ} (h : i < c.length) : c.sizeUpTo i < c.sizeUpTo (i + 1) 
Arguments: {n : ℕ} (c : Composition n) {i : ℕ} (h : i < c.length)
Goal: c.sizeUpTo i < c.sizeUpTo (i + 1)
-- Composition.monotone_sizeUpTo
theorem monotone_sizeUpTo : Monotone c.sizeUpTo 
Arguments: {n : ℕ} (c : Composition n)
Goal: Monotone c.sizeUpTo
-- Composition.boundary_zero
@[simp]
theorem boundary_zero : c.boundary 0 = 0 
Arguments: {n : ℕ} (c : Composition n)
Goal: c.boundary 0 = 0
-- Composition.boundary_last
@[simp]
theorem boundary_last : c.boundary (Fin.last c.length) = Fin.last n 
Arguments: {n : ℕ} (c : Composition n)
Goal: c.boundary (Fin.last c.length) = Fin.last n
-- Composition.card_boundaries_eq_succ_length
theorem card_boundaries_eq_succ_length : c.boundaries.card = c.length + 1 
Arguments: {n : ℕ} (c : Composition n)
Goal: c.boundaries.card = c.length + 1
-- Composition.orderEmbOfFin_boundaries
theorem orderEmbOfFin_boundaries :
    c.boundaries.orderEmbOfFin c.card_boundaries_eq_succ_length = c.boundary 
Arguments: {n : ℕ} (c : Composition n)
Goal: c.boundaries.orderEmbOfFin ⋯ = c.boundary
-- Composition.coe_embedding
@[simp]
theorem coe_embedding (i : Fin c.length) (j : Fin (c.blocksFun i)) :
    (c.embedding i j : ℕ) = c.sizeUpTo i + j 
Arguments: {n : ℕ} (c : Composition n) (i : Fin c.length) (j : Fin (c.blocksFun i))
Goal: ↑((c.embedding i) j) = c.sizeUpTo ↑i + ↑j
-- Composition.index_exists
theorem index_exists {j : ℕ} (h : j < n) : ∃ i : ℕ, j < c.sizeUpTo (i + 1) ∧ i < c.length 
Arguments: {n : ℕ} (c : Composition n) {j : ℕ} (h : j < n)
Goal: ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
-- Composition.lt_sizeUpTo_index_succ
theorem lt_sizeUpTo_index_succ (j : Fin n) : (j : ℕ) < c.sizeUpTo (c.index j).succ 
Arguments: {n : ℕ} (c : Composition n) (j : Fin n)
Goal: ↑j < c.sizeUpTo ↑(c.index j).succ
-- Composition.sizeUpTo_index_le
theorem sizeUpTo_index_le (j : Fin n) : c.sizeUpTo (c.index j) ≤ j 
Arguments: {n : ℕ} (c : Composition n) (j : Fin n)
Goal: c.sizeUpTo ↑(c.index j) ≤ ↑j
-- Composition.coe_invEmbedding
@[simp]
theorem coe_invEmbedding (j : Fin n) : (c.invEmbedding j : ℕ) = j - c.sizeUpTo (c.index j) 
Arguments: {n : ℕ} (c : Composition n) (j : Fin n)
Goal: ↑(c.invEmbedding j) = ↑j - c.sizeUpTo ↑(c.index j)
-- Composition.embedding_comp_inv
theorem embedding_comp_inv (j : Fin n) : c.embedding (c.index j) (c.invEmbedding j) = j 
Arguments: {n : ℕ} (c : Composition n) (j : Fin n)
Goal: (c.embedding (c.index j)) (c.invEmbedding j) = j
-- Composition.mem_range_embedding_iff
theorem mem_range_embedding_iff {j : Fin n} {i : Fin c.length} :
    j ∈ Set.range (c.embedding i) ↔ c.sizeUpTo i ≤ j ∧ (j : ℕ) < c.sizeUpTo (i : ℕ).succ 
Arguments: {n : ℕ} (c : Composition n) {j : Fin n} {i : Fin c.length}
Goal: j ∈ Set.range ⇑(c.embedding i) ↔ c.sizeUpTo ↑i ≤ ↑j ∧ ↑j < c.sizeUpTo (↑i).succ
-- Composition.disjoint_range
theorem disjoint_range {i₁ i₂ : Fin c.length} (h : i₁ ≠ i₂) :
    Disjoint (Set.range (c.embedding i₁)) (Set.range (c.embedding i₂)) 
Arguments: {n : ℕ} (c : Composition n) {i₁ i₂ : Fin c.length} (h : i₁ ≠ i₂)
Goal: Disjoint (Set.range ⇑(c.embedding i₁)) (Set.range ⇑(c.embedding i₂))
-- Composition.mem_range_embedding
theorem mem_range_embedding (j : Fin n) : j ∈ Set.range (c.embedding (c.index j)) 
Arguments: {n : ℕ} (c : Composition n) (j : Fin n)
Goal: j ∈ Set.range ⇑(c.embedding (c.index j))
-- Composition.mem_range_embedding_iff'
theorem mem_range_embedding_iff' {j : Fin n} {i : Fin c.length} :
    j ∈ Set.range (c.embedding i) ↔ i = c.index j 
Arguments: {n : ℕ} (c : Composition n) {j : Fin n} {i : Fin c.length}
Goal: j ∈ Set.range ⇑(c.embedding i) ↔ i = c.index j
-- Composition.index_embedding
theorem index_embedding (i : Fin c.length) (j : Fin (c.blocksFun i)) :
    c.index (c.embedding i j) = i 
Arguments: {n : ℕ} (c : Composition n) (i : Fin c.length) (j : Fin (c.blocksFun i))
Goal: c.index ((c.embedding i) j) = i
-- Composition.invEmbedding_comp
theorem invEmbedding_comp (i : Fin c.length) (j : Fin (c.blocksFun i)) :
    (c.invEmbedding (c.embedding i j) : ℕ) = j 
Arguments: {n : ℕ} (c : Composition n) (i : Fin c.length) (j : Fin (c.blocksFun i))
Goal: ↑(c.invEmbedding ((c.embedding i) j)) = ↑j
-- Composition.blocksFun_congr
theorem blocksFun_congr {n₁ n₂ : ℕ} (c₁ : Composition n₁) (c₂ : Composition n₂) (i₁ : Fin c₁.length)
    (i₂ : Fin c₂.length) (hn : n₁ = n₂) (hc : c₁.blocks = c₂.blocks) (hi : (i₁ : ℕ) = i₂) :
    c₁.blocksFun i₁ = c₂.blocksFun i₂ 
Arguments: {n₁ n₂ : ℕ} (c₁ : Composition n₁) (c₂ : Composition n₂) (i₁ : Fin c₁.length) (i₂ : Fin c₂.length) (hn : n₁ = n₂) (hc : c₁.blocks = c₂.blocks) (hi : ↑i₁ = ↑i₂)
Goal: c₁.blocksFun i₁ = c₂.blocksFun i₂
-- Composition.sigma_eq_iff_blocks_eq
theorem sigma_eq_iff_blocks_eq {c : Σn, Composition n} {c' : Σn, Composition n} :
    c = c' ↔ c.2.blocks = c'.2.blocks 
Arguments: {c c' : (n : ℕ) × Composition n}
Goal: c = c' ↔ c.snd.blocks = c'.snd.blocks
-- Composition.ones_length
@[simp]
theorem ones_length (n : ℕ) : (ones n).length = n 
Arguments: (n : ℕ)
Goal: (Composition.ones n).length = n
-- Composition.ones_blocks
@[simp]
theorem ones_blocks (n : ℕ) : (ones n).blocks = replicate n (1 : ℕ) 
Arguments: (n : ℕ)
Goal: (Composition.ones n).blocks = List.replicate n 1
-- Composition.ones_blocksFun
@[simp]
theorem ones_blocksFun (n : ℕ) (i : Fin (ones n).length) : (ones n).blocksFun i = 1 
Arguments: (n : ℕ) (i : Fin (Composition.ones n).length)
Goal: (Composition.ones n).blocksFun i = 1
-- Composition.ones_sizeUpTo
@[simp]
theorem ones_sizeUpTo (n : ℕ) (i : ℕ) : (ones n).sizeUpTo i = min i n 
Arguments: (n i : ℕ)
Goal: (Composition.ones n).sizeUpTo i = min i n
-- Composition.ones_embedding
@[simp]
theorem ones_embedding (i : Fin (ones n).length) (h : 0 < (ones n).blocksFun i) :
    (ones n).embedding i ⟨0, h⟩ = ⟨i, lt_of_lt_of_le i.2 (ones n).length_le⟩ 
Arguments: {n : ℕ} (i : Fin (Composition.ones n).length) (h : 0 < (Composition.ones n).blocksFun i)
Goal: ((Composition.ones n).embedding i) ⟨0, h⟩ = ⟨↑i, ⋯⟩
-- Composition.eq_ones_iff
theorem eq_ones_iff {c : Composition n} : c = ones n ↔ ∀ i ∈ c.blocks, i = 1 
Arguments: {n : ℕ} {c : Composition n}
Goal: c = Composition.ones n ↔ ∀ i ∈ c.blocks, i = 1
-- Composition.ne_ones_iff
theorem ne_ones_iff {c : Composition n} : c ≠ ones n ↔ ∃ i ∈ c.blocks, 1 < i 
Arguments: {n : ℕ} {c : Composition n}
Goal: c ≠ Composition.ones n ↔ ∃ i ∈ c.blocks, 1 < i
-- Composition.eq_ones_iff_length
theorem eq_ones_iff_length {c : Composition n} : c = ones n ↔ c.length = n 
Arguments: {n : ℕ} {c : Composition n}
Goal: c = Composition.ones n ↔ c.length = n
-- Composition.eq_ones_iff_le_length
theorem eq_ones_iff_le_length {c : Composition n} : c = ones n ↔ n ≤ c.length 
Arguments: {n : ℕ} {c : Composition n}
Goal: c = Composition.ones n ↔ n ≤ c.length
-- Composition.single_length
@[simp]
theorem single_length {n : ℕ} (h : 0 < n) : (single n h).length = 1 
Arguments: {n : ℕ} (h : 0 < n)
Goal: (Composition.single n h).length = 1
-- Composition.single_blocks
@[simp]
theorem single_blocks {n : ℕ} (h : 0 < n) : (single n h).blocks = [n] 
Arguments: {n : ℕ} (h : 0 < n)
Goal: (Composition.single n h).blocks = [n]
-- Composition.single_blocksFun
@[simp]
theorem single_blocksFun {n : ℕ} (h : 0 < n) (i : Fin (single n h).length) :
    (single n h).blocksFun i = n 
Arguments: {n : ℕ} (h : 0 < n) (i : Fin (Composition.single n h).length)
Goal: (Composition.single n h).blocksFun i = n
-- Composition.single_embedding
@[simp]
theorem single_embedding {n : ℕ} (h : 0 < n) (i : Fin n) :
    ((single n h).embedding (0 : Fin 1)) i = i 
Arguments: {n : ℕ} (h : 0 < n) (i : Fin n)
Goal: ((Composition.single n h).embedding 0) i = i
-- Composition.eq_single_iff_length
theorem eq_single_iff_length {n : ℕ} (h : 0 < n) {c : Composition n} :
    c = single n h ↔ c.length = 1 
Arguments: {n : ℕ} (h : 0 < n) {c : Composition n}
Goal: c = Composition.single n h ↔ c.length = 1
-- Composition.ne_single_iff
theorem ne_single_iff {n : ℕ} (hn : 0 < n) {c : Composition n} :
    c ≠ single n hn ↔ ∀ i, c.blocksFun i < n 
Arguments: {n : ℕ} (hn : 0 < n) {c : Composition n}
Goal: c ≠ Composition.single n hn ↔ ∀ (i : Fin c.length), c.blocksFun i < n
-- List.splitWrtCompositionAux_cons
@[local simp]
theorem splitWrtCompositionAux_cons (l : List α) (n ns) :
    l.splitWrtCompositionAux (n::ns) = take n l::(drop n l).splitWrtCompositionAux ns 
Arguments: {α : Type u_1} (l : List α) (n : ℕ) (ns : List ℕ)
Goal: l.splitWrtCompositionAux (n :: ns) = List.take n l :: (List.drop n l).splitWrtCompositionAux ns
-- List.length_splitWrtCompositionAux
theorem length_splitWrtCompositionAux (l : List α) (ns) :
    length (l.splitWrtCompositionAux ns) = ns.length 
Arguments: {α : Type u_1} (l : List α) (ns : List ℕ)
Goal: (l.splitWrtCompositionAux ns).length = ns.length
-- List.length_splitWrtComposition
@[simp]
theorem length_splitWrtComposition (l : List α) (c : Composition n) :
    length (l.splitWrtComposition c) = c.length 
Arguments: {n : ℕ} {α : Type u_1} (l : List α) (c : Composition n)
Goal: (l.splitWrtComposition c).length = c.length
-- List.map_length_splitWrtCompositionAux
theorem map_length_splitWrtCompositionAux {ns : List ℕ} :
    ∀ {l : List α}, ns.sum ≤ l.length → map length (l.splitWrtCompositionAux ns) = ns 
Arguments: {α : Type u_1} {ns : List ℕ} {l : List α}
Goal: ns.sum ≤ l.length → List.map List.length (l.splitWrtCompositionAux ns) = ns
-- List.map_length_splitWrtComposition
theorem map_length_splitWrtComposition (l : List α) (c : Composition l.length) :
    map length (l.splitWrtComposition c) = c.blocks 
Arguments: {α : Type u_1} (l : List α) (c : Composition l.length)
Goal: List.map List.length (l.splitWrtComposition c) = c.blocks
-- List.length_pos_of_mem_splitWrtComposition
theorem length_pos_of_mem_splitWrtComposition {l l' : List α} {c : Composition l.length}
    (h : l' ∈ l.splitWrtComposition c) : 0 < length l' 
Arguments: {α : Type u_1} {l l' : List α} {c : Composition l.length} (h : l' ∈ l.splitWrtComposition c)
Goal: 0 < l'.length
-- List.sum_take_map_length_splitWrtComposition
theorem sum_take_map_length_splitWrtComposition (l : List α) (c : Composition l.length) (i : ℕ) :
    (((l.splitWrtComposition c).map length).take i).sum = c.sizeUpTo i 
Arguments: {α : Type u_1} (l : List α) (c : Composition l.length) (i : ℕ)
Goal: (List.take i (List.map List.length (l.splitWrtComposition c))).sum = c.sizeUpTo i
-- List.getElem_splitWrtCompositionAux
theorem getElem_splitWrtCompositionAux (l : List α) (ns : List ℕ) {i : ℕ}
    (hi : i < (l.splitWrtCompositionAux ns).length) :
    (l.splitWrtCompositionAux ns)[i] =
      (l.take (ns.take (i + 1)).sum).drop (ns.take i).sum 
Arguments: {α : Type u_1} (l : List α) (ns : List ℕ) {i : ℕ} (hi : i < (l.splitWrtCompositionAux ns).length)
Goal: (l.splitWrtCompositionAux ns)[i] = List.drop (List.take i ns).sum (List.take (List.take (i + 1) ns).sum l)
-- List.getElem_splitWrtComposition'
theorem getElem_splitWrtComposition' (l : List α) (c : Composition n) {i : ℕ}
    (hi : i < (l.splitWrtComposition c).length) :
    (l.splitWrtComposition c)[i] = (l.take (c.sizeUpTo (i + 1))).drop (c.sizeUpTo i) 
Arguments: {n : ℕ} {α : Type u_1} (l : List α) (c : Composition n) {i : ℕ} (hi : i < (l.splitWrtComposition c).length)
Goal: (l.splitWrtComposition c)[i] = List.drop (c.sizeUpTo i) (List.take (c.sizeUpTo (i + 1)) l)
-- List.getElem_splitWrtComposition
theorem getElem_splitWrtComposition (l : List α) (c : Composition n)
    (i : Nat) (h : i < (l.splitWrtComposition c).length) :
    (l.splitWrtComposition c)[i] = (l.take (c.sizeUpTo (i + 1))).drop (c.sizeUpTo i) 
Arguments: {n : ℕ} {α : Type u_1} (l : List α) (c : Composition n) (i : ℕ) (h : i < (l.splitWrtComposition c).length)
Goal: (l.splitWrtComposition c)[i] = List.drop (c.sizeUpTo i) (List.take (c.sizeUpTo (i + 1)) l)
-- List.get_splitWrtCompositionAux
@[deprecated getElem_splitWrtCompositionAux (since := "2024-06-12")]
theorem get_splitWrtCompositionAux (l : List α) (ns : List ℕ) {i : ℕ} (hi) :
    (l.splitWrtCompositionAux ns).get ⟨i, hi⟩  =
      (l.take (ns.take (i + 1)).sum).drop (ns.take i).sum 
Arguments: {α : Type u_1} (l : List α) (ns : List ℕ) {i : ℕ} (hi : i < (l.splitWrtCompositionAux ns).length)
Goal: (l.splitWrtCompositionAux ns).get ⟨i, hi⟩ = List.drop (List.take i ns).sum (List.take (List.take (i + 1) ns).sum l)
-- List.get_splitWrtComposition'
@[deprecated getElem_splitWrtComposition' (since := "2024-06-12")]
theorem get_splitWrtComposition' (l : List α) (c : Composition n) {i : ℕ}
    (hi : i < (l.splitWrtComposition c).length) :
    (l.splitWrtComposition c).get ⟨i, hi⟩ = (l.take (c.sizeUpTo (i + 1))).drop (c.sizeUpTo i) 
Arguments: {n : ℕ} {α : Type u_1} (l : List α) (c : Composition n) {i : ℕ} (hi : i < (l.splitWrtComposition c).length)
Goal: (l.splitWrtComposition c).get ⟨i, hi⟩ = List.drop (c.sizeUpTo i) (List.take (c.sizeUpTo (i + 1)) l)
-- List.get_splitWrtComposition
@[deprecated getElem_splitWrtComposition (since := "2024-06-12")]
theorem get_splitWrtComposition (l : List α) (c : Composition n)
    (i : Fin (l.splitWrtComposition c).length) :
    get (l.splitWrtComposition c) i = (l.take (c.sizeUpTo (i + 1))).drop (c.sizeUpTo i) 
Arguments: {n : ℕ} {α : Type u_1} (l : List α) (c : Composition n) (i : Fin (l.splitWrtComposition c).length)
Goal: (l.splitWrtComposition c).get i = List.drop (c.sizeUpTo ↑i) (List.take (c.sizeUpTo (↑i + 1)) l)
-- List.join_splitWrtCompositionAux
theorem join_splitWrtCompositionAux {ns : List ℕ} :
    ∀ {l : List α}, ns.sum = l.length → (l.splitWrtCompositionAux ns).join = l 
Arguments: {α : Type u_1} {ns : List ℕ} {l : List α}
Goal: ns.sum = l.length → (l.splitWrtCompositionAux ns).join = l
-- List.join_splitWrtComposition
@[simp]
theorem join_splitWrtComposition (l : List α) (c : Composition l.length) :
    (l.splitWrtComposition c).join = l 
Arguments: {α : Type u_1} (l : List α) (c : Composition l.length)
Goal: (l.splitWrtComposition c).join = l
-- List.splitWrtComposition_join
@[simp]
theorem splitWrtComposition_join (L : List (List α)) (c : Composition L.join.length)
    (h : map length L = c.blocks) : splitWrtComposition (join L) c = L 
Arguments: {α : Type u_1} (L : List (List α)) (c : Composition L.join.length) (h : List.map List.length L = c.blocks)
Goal: L.join.splitWrtComposition c = L
-- compositionAsSet_card
theorem compositionAsSet_card (n : ℕ) : Fintype.card (CompositionAsSet n) = 2 ^ (n - 1) 
Arguments: (n : ℕ)
Goal: Fintype.card (CompositionAsSet n) = 2 ^ (n - 1)
-- CompositionAsSet.boundaries_nonempty
theorem boundaries_nonempty : c.boundaries.Nonempty 
Arguments: {n : ℕ} (c : CompositionAsSet n)
Goal: c.boundaries.Nonempty
-- CompositionAsSet.card_boundaries_pos
theorem card_boundaries_pos : 0 < Finset.card c.boundaries 
Arguments: {n : ℕ} (c : CompositionAsSet n)
Goal: 0 < c.boundaries.card
-- CompositionAsSet.card_boundaries_eq_succ_length
theorem card_boundaries_eq_succ_length : c.boundaries.card = c.length + 1 
Arguments: {n : ℕ} (c : CompositionAsSet n)
Goal: c.boundaries.card = c.length + 1
-- CompositionAsSet.length_lt_card_boundaries
theorem length_lt_card_boundaries : c.length < c.boundaries.card 
Arguments: {n : ℕ} (c : CompositionAsSet n)
Goal: c.length < c.boundaries.card
-- CompositionAsSet.lt_length
theorem lt_length (i : Fin c.length) : (i : ℕ) + 1 < c.boundaries.card 
Arguments: {n : ℕ} (c : CompositionAsSet n) (i : Fin c.length)
Goal: ↑i + 1 < c.boundaries.card
-- CompositionAsSet.lt_length'
theorem lt_length' (i : Fin c.length) : (i : ℕ) < c.boundaries.card 
Arguments: {n : ℕ} (c : CompositionAsSet n) (i : Fin c.length)
Goal: ↑i < c.boundaries.card