ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Equiv.Perm.isCycle_iff_sameCycle
theorem isCycle_iff_sameCycle (hx : f x ≠ x) : IsCycle f ↔ ∀ {y}, SameCycle f x y ↔ f y ≠ y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x : α} (hx : f x ≠ x)
Goal: f.IsCycle ↔ ∀ {y : α}, f.SameCycle x y ↔ f y ≠ y
-- Equiv.Perm.IsCycle.exists_pow_eq
theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y) :
    ∃ i : ℕ, (f ^ i) x = y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} [Finite α] (hf : f.IsCycle) (hx : f x ≠ x) (hy : f y ≠ y)
Goal: ∃ i, (f ^ i) x = y
-- Equiv.Perm.isCycle_swap
theorem isCycle_swap (hxy : x ≠ y) : IsCycle (swap x y) 
Arguments: {α : Type u_2} {x y : α} [DecidableEq α] (hxy : x ≠ y)
Goal: (Equiv.swap x y).IsCycle
-- Equiv.Perm.IsSwap.isCycle
protected theorem IsSwap.isCycle : IsSwap f → IsCycle f 
Arguments: {α : Type u_2} {f : Equiv.Perm α} [DecidableEq α]
Goal: f.IsSwap → f.IsCycle
-- Equiv.Perm.IsCycle.two_le_card_support
theorem IsCycle.two_le_card_support (h : IsCycle f) : 2 ≤ f.support.card 
Arguments: {α : Type u_2} {f : Equiv.Perm α} [DecidableEq α] [Fintype α] (h : f.IsCycle)
Goal: 2 ≤ f.support.card
-- Equiv.Perm.IsCycle.zpowersEquivSupport_apply
@[simp]
theorem IsCycle.zpowersEquivSupport_apply {σ : Perm α} (hσ : IsCycle σ) {n : ℕ} :
    hσ.zpowersEquivSupport ⟨σ ^ n, n, rfl⟩ =
      ⟨(σ ^ n) (Classical.choose hσ),
        pow_apply_mem_support.2 (mem_support.2 (Classical.choose_spec hσ).1)⟩ 
Arguments: {α : Type u_2} [DecidableEq α] [Fintype α] {σ : Equiv.Perm α} (hσ : σ.IsCycle) {n : ℕ}
Goal: hσ.zpowersEquivSupport ⟨σ ^ n, ⋯⟩ = ⟨(σ ^ n) (Classical.choose hσ), ⋯⟩
-- Equiv.Perm.IsCycle.zpowersEquivSupport_symm_apply
@[simp]
theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ) (n : ℕ) :
    hσ.zpowersEquivSupport.symm
        ⟨(σ ^ n) (Classical.choose hσ),
          pow_apply_mem_support.2 (mem_support.2 (Classical.choose_spec hσ).1)⟩ =
      ⟨σ ^ n, n, rfl⟩ 
Arguments: {α : Type u_2} [DecidableEq α] [Fintype α] {σ : Equiv.Perm α} (hσ : σ.IsCycle) (n : ℕ)
Goal: hσ.zpowersEquivSupport.symm ⟨(σ ^ n) (Classical.choose hσ), ⋯⟩ = ⟨σ ^ n, ⋯⟩
-- Equiv.Perm.IsCycle.orderOf
protected theorem IsCycle.orderOf (hf : IsCycle f) : orderOf f = f.support.card 
Arguments: {α : Type u_2} {f : Equiv.Perm α} [DecidableEq α] [Fintype α] (hf : f.IsCycle)
Goal: orderOf f = f.support.card
-- Equiv.Perm.isCycle_swap_mul_aux₁
theorem isCycle_swap_mul_aux₁ {α : Type*} [DecidableEq α] :
    ∀ (n : ℕ) {b x : α} {f : Perm α} (_ : (swap x (f x) * f) b ≠ b) (_ : (f ^ n) (f x) = b),
      ∃ i : ℤ, ((swap x (f x) * f) ^ i) (f x) = b 
Arguments: {α : Type u_4} [DecidableEq α] (n : ℕ) {b x : α} {f : Equiv.Perm α}
Goal: (Equiv.swap x (f x) * f) b ≠ b → (f ^ n) (f x) = b → ∃ i, ((Equiv.swap x (f x) * f) ^ i) (f x) = b
-- Equiv.Perm.isCycle_swap_mul_aux₂
theorem isCycle_swap_mul_aux₂ {α : Type*} [DecidableEq α] :
    ∀ (n : ℤ) {b x : α} {f : Perm α} (_ : (swap x (f x) * f) b ≠ b) (_ : (f ^ n) (f x) = b),
      ∃ i : ℤ, ((swap x (f x) * f) ^ i) (f x) = b 
Arguments: {α : Type u_4} [DecidableEq α] (n : ℤ) {b x : α} {f : Equiv.Perm α}
Goal: (Equiv.swap x (f x) * f) b ≠ b → (f ^ n) (f x) = b → ∃ i, ((Equiv.swap x (f x) * f) ^ i) (f x) = b
-- Equiv.Perm.IsCycle.eq_swap_of_apply_apply_eq_self
theorem IsCycle.eq_swap_of_apply_apply_eq_self {α : Type*} [DecidableEq α] {f : Perm α}
    (hf : IsCycle f) {x : α} (hfx : f x ≠ x) (hffx : f (f x) = x) : f = swap x (f x) 
Arguments: {α : Type u_4} [DecidableEq α] {f : Equiv.Perm α} (hf : f.IsCycle) {x : α} (hfx : f x ≠ x) (hffx : f (f x) = x)
Goal: f = Equiv.swap x (f x)
-- Equiv.Perm.IsCycle.swap_mul
theorem IsCycle.swap_mul {α : Type*} [DecidableEq α] {f : Perm α} (hf : IsCycle f) {x : α}
    (hx : f x ≠ x) (hffx : f (f x) ≠ x) : IsCycle (swap x (f x) * f) 
Arguments: {α : Type u_4} [DecidableEq α] {f : Equiv.Perm α} (hf : f.IsCycle) {x : α} (hx : f x ≠ x) (hffx : f (f x) ≠ x)
Goal: (Equiv.swap x (f x) * f).IsCycle
-- Equiv.Perm.IsCycle.sign
theorem IsCycle.sign {f : Perm α} (hf : IsCycle f) : sign f = -(-1) ^ f.support.card 
Arguments: {α : Type u_2} [DecidableEq α] [Fintype α] {f : Equiv.Perm α} (hf : f.IsCycle)
Goal: Equiv.Perm.sign f = -(-1) ^ f.support.card
-- Equiv.Perm.IsCycle.of_pow
theorem IsCycle.of_pow {n : ℕ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f ^ n).support) :
    IsCycle f 
Arguments: {α : Type u_2} {f : Equiv.Perm α} [DecidableEq α] [Fintype α] {n : ℕ} (h1 : (f ^ n).IsCycle) (h2 : f.support ⊆ (f ^ n).support)
Goal: f.IsCycle
-- Equiv.Perm.IsCycle.of_zpow
theorem IsCycle.of_zpow {n : ℤ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f ^ n).support) :
    IsCycle f 
Arguments: {α : Type u_2} {f : Equiv.Perm α} [DecidableEq α] [Fintype α] {n : ℤ} (h1 : (f ^ n).IsCycle) (h2 : f.support ⊆ (f ^ n).support)
Goal: f.IsCycle
-- Equiv.Perm.nodup_of_pairwise_disjoint_cycles
theorem nodup_of_pairwise_disjoint_cycles {l : List (Perm β)} (h1 : ∀ f ∈ l, IsCycle f)
    (h2 : l.Pairwise Disjoint) : l.Nodup 
Arguments: {β : Type u_3} {l : List (Equiv.Perm β)} (h1 : ∀ f ∈ l, f.IsCycle) (h2 : List.Pairwise Equiv.Perm.Disjoint l)
Goal: l.Nodup
-- Equiv.Perm.IsCycle.support_congr
theorem IsCycle.support_congr (hf : IsCycle f) (hg : IsCycle g) (h : f.support ⊆ g.support)
    (h' : ∀ x ∈ f.support, f x = g x) : f = g 
Arguments: {α : Type u_2} {f g : Equiv.Perm α} [DecidableEq α] [Fintype α] (hf : f.IsCycle) (hg : g.IsCycle) (h : f.support ⊆ g.support) (h' : ∀ x ∈ f.support, f x = g x)
Goal: f = g
-- Equiv.Perm.IsCycle.eq_on_support_inter_nonempty_congr
theorem IsCycle.eq_on_support_inter_nonempty_congr (hf : IsCycle f) (hg : IsCycle g)
    (h : ∀ x ∈ f.support ∩ g.support, f x = g x)
    (hx : f x = g x) (hx' : x ∈ f.support) : f = g 
Arguments: {α : Type u_2} {f g : Equiv.Perm α} {x : α} [DecidableEq α] [Fintype α] (hf : f.IsCycle) (hg : g.IsCycle) (h : ∀ x ∈ f.support ∩ g.support, f x = g x) (hx : f x = g x) (hx' : x ∈ f.support)
Goal: f = g
-- Equiv.Perm.IsCycle.support_pow_eq_iff
theorem IsCycle.support_pow_eq_iff (hf : IsCycle f) {n : ℕ} :
    support (f ^ n) = support f ↔ ¬orderOf f ∣ n 
Arguments: {α : Type u_2} {f : Equiv.Perm α} [DecidableEq α] [Fintype α] (hf : f.IsCycle) {n : ℕ}
Goal: (f ^ n).support = f.support ↔ ¬orderOf f ∣ n
-- Equiv.Perm.IsCycle.support_pow_of_pos_of_lt_orderOf
theorem IsCycle.support_pow_of_pos_of_lt_orderOf (hf : IsCycle f) {n : ℕ} (npos : 0 < n)
    (hn : n < orderOf f) : (f ^ n).support = f.support 
Arguments: {α : Type u_2} {f : Equiv.Perm α} [DecidableEq α] [Fintype α] (hf : f.IsCycle) {n : ℕ} (npos : 0 < n) (hn : n < orderOf f)
Goal: (f ^ n).support = f.support
-- Equiv.Perm.IsCycle.pow_iff
theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
    IsCycle (f ^ n) ↔ n.Coprime (orderOf f) 
Arguments: {β : Type u_3} [Finite β] {f : Equiv.Perm β} (hf : f.IsCycle) {n : ℕ}
Goal: (f ^ n).IsCycle ↔ n.Coprime (orderOf f)
-- Equiv.Perm.IsCycle.pow_eq_one_iff
theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
    f ^ n = 1 ↔ ∃ x, f x ≠ x ∧ (f ^ n) x = x 
Arguments: {β : Type u_3} [Finite β] {f : Equiv.Perm β} (hf : f.IsCycle) {n : ℕ}
Goal: f ^ n = 1 ↔ ∃ x, f x ≠ x ∧ (f ^ n) x = x
-- Equiv.Perm.IsCycle.pow_eq_one_iff'
theorem IsCycle.pow_eq_one_iff' [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} {x : β}
    (hx : f x ≠ x) : f ^ n = 1 ↔ (f ^ n) x = x 
Arguments: {β : Type u_3} [Finite β] {f : Equiv.Perm β} (hf : f.IsCycle) {n : ℕ} {x : β} (hx : f x ≠ x)
Goal: f ^ n = 1 ↔ (f ^ n) x = x
-- Equiv.Perm.IsCycle.pow_eq_one_iff''
theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
    f ^ n = 1 ↔ ∀ x, f x ≠ x → (f ^ n) x = x 
Arguments: {β : Type u_3} [Finite β] {f : Equiv.Perm β} (hf : f.IsCycle) {n : ℕ}
Goal: f ^ n = 1 ↔ ∀ (x : β), f x ≠ x → (f ^ n) x = x
-- Equiv.Perm.IsCycle.pow_eq_pow_iff
theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b : ℕ} :
    f ^ a = f ^ b ↔ ∃ x, f x ≠ x ∧ (f ^ a) x = (f ^ b) x 
Arguments: {β : Type u_3} [Finite β] {f : Equiv.Perm β} (hf : f.IsCycle) {a b : ℕ}
Goal: f ^ a = f ^ b ↔ ∃ x, f x ≠ x ∧ (f ^ a) x = (f ^ b) x
-- Equiv.Perm.IsCycle.isCycle_pow_pos_of_lt_prime_order
theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf : IsCycle f)
    (hf' : (orderOf f).Prime) (n : ℕ) (hn : 0 < n) (hn' : n < orderOf f) : IsCycle (f ^ n) 
Arguments: {β : Type u_3} [Finite β] {f : Equiv.Perm β} (hf : f.IsCycle) (hf' : Nat.Prime (orderOf f)) (n : ℕ) (hn : 0 < n) (hn' : n < orderOf f)
Goal: (f ^ n).IsCycle
-- Int.addLeft_one_isCycle
theorem _root_.Int.addLeft_one_isCycle : (Equiv.addLeft 1 : Perm ℤ).IsCycle 
Goal: (Equiv.addLeft 1).IsCycle
-- Int.addRight_one_isCycle
theorem _root_.Int.addRight_one_isCycle : (Equiv.addRight 1 : Perm ℤ).IsCycle 
Goal: (Equiv.addRight 1).IsCycle
-- Equiv.Perm.IsCycle.isConj
theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.card = τ.support.card) :
    IsConj σ τ 
Arguments: {α : Type u_2} [Fintype α] [DecidableEq α] {σ τ : Equiv.Perm α} (hσ : σ.IsCycle) (hτ : τ.IsCycle) (h : σ.support.card = τ.support.card)
Goal: IsConj σ τ
-- Equiv.Perm.IsCycle.isConj_iff
theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :
    IsConj σ τ ↔ σ.support.card = τ.support.card 
Arguments: {α : Type u_2} [Fintype α] [DecidableEq α] {σ τ : Equiv.Perm α} (hσ : σ.IsCycle) (hτ : τ.IsCycle)
Goal: IsConj σ τ ↔ σ.support.card = τ.support.card
-- Equiv.Perm.isCycleOn_empty
@[simp]
theorem isCycleOn_empty : f.IsCycleOn ∅ 
Arguments: {α : Type u_2} {f : Equiv.Perm α}
Goal: f.IsCycleOn ∅
-- Equiv.Perm.isCycleOn_one
@[simp]
theorem isCycleOn_one : (1 : Perm α).IsCycleOn s ↔ s.Subsingleton 
Arguments: {α : Type u_2} {s : Set α}
Goal: Equiv.Perm.IsCycleOn 1 s ↔ s.Subsingleton
-- Equiv.Perm.isCycleOn_singleton
@[simp]
theorem isCycleOn_singleton : f.IsCycleOn {a} ↔ f a = a 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {a : α}
Goal: f.IsCycleOn {a} ↔ f a = a
-- Equiv.Perm.isCycleOn_of_subsingleton
theorem isCycleOn_of_subsingleton [Subsingleton α] (f : Perm α) (s : Set α) : f.IsCycleOn s 
Arguments: {α : Type u_2} [Subsingleton α] (f : Equiv.Perm α) (s : Set α)
Goal: f.IsCycleOn s
-- Equiv.Perm.isCycleOn_inv
@[simp]
theorem isCycleOn_inv : f⁻¹.IsCycleOn s ↔ f.IsCycleOn s 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α}
Goal: f⁻¹.IsCycleOn s ↔ f.IsCycleOn s
-- Equiv.Perm.IsCycleOn.conj
theorem IsCycleOn.conj (h : f.IsCycleOn s) : (g * f * g⁻¹).IsCycleOn ((g : Perm α) '' s) 
Arguments: {α : Type u_2} {f g : Equiv.Perm α} {s : Set α} (h : f.IsCycleOn s)
Goal: (g * f * g⁻¹).IsCycleOn (⇑g '' s)
-- Equiv.Perm.isCycleOn_swap
theorem isCycleOn_swap [DecidableEq α] (hab : a ≠ b) : (swap a b).IsCycleOn {a, b} 
Arguments: {α : Type u_2} {a b : α} [DecidableEq α] (hab : a ≠ b)
Goal: (Equiv.swap a b).IsCycleOn {a, b}
-- Equiv.Perm.IsCycleOn.apply_ne
protected theorem IsCycleOn.apply_ne (hf : f.IsCycleOn s) (hs : s.Nontrivial) (ha : a ∈ s) :
    f a ≠ a 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α} {a : α} (hf : f.IsCycleOn s) (hs : s.Nontrivial) (ha : a ∈ s)
Goal: f a ≠ a
-- Equiv.Perm.IsCycle.isCycleOn
protected theorem IsCycle.isCycleOn (hf : f.IsCycle) : f.IsCycleOn { x | f x ≠ x } 
Arguments: {α : Type u_2} {f : Equiv.Perm α} (hf : f.IsCycle)
Goal: f.IsCycleOn {x | f x ≠ x}
-- Equiv.Perm.isCycle_iff_exists_isCycleOn
theorem isCycle_iff_exists_isCycleOn :
    f.IsCycle ↔ ∃ s : Set α, s.Nontrivial ∧ f.IsCycleOn s ∧ ∀ ⦃x⦄, ¬IsFixedPt f x → x ∈ s 
Arguments: {α : Type u_2} {f : Equiv.Perm α}
Goal: f.IsCycle ↔ ∃ s, s.Nontrivial ∧ f.IsCycleOn s ∧ ∀ ⦃x : α⦄, ¬Function.IsFixedPt (⇑f) x → x ∈ s
-- Equiv.Perm.IsCycleOn.apply_mem_iff
theorem IsCycleOn.apply_mem_iff (hf : f.IsCycleOn s) : f x ∈ s ↔ x ∈ s 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α} {x : α} (hf : f.IsCycleOn s)
Goal: f x ∈ s ↔ x ∈ s
-- Equiv.Perm.IsCycleOn.isCycle_subtypePerm
theorem IsCycleOn.isCycle_subtypePerm (hf : f.IsCycleOn s) (hs : s.Nontrivial) :
    (f.subtypePerm fun _ => hf.apply_mem_iff.symm : Perm s).IsCycle 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α} (hf : f.IsCycleOn s) (hs : s.Nontrivial)
Goal: (f.subtypePerm ⋯).IsCycle
-- Equiv.Perm.IsCycleOn.subtypePerm
protected theorem IsCycleOn.subtypePerm (hf : f.IsCycleOn s) :
    (f.subtypePerm fun _ => hf.apply_mem_iff.symm : Perm s).IsCycleOn _root_.Set.univ 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α} (hf : f.IsCycleOn s)
Goal: (f.subtypePerm ⋯).IsCycleOn Set.univ
-- Equiv.Perm.IsCycleOn.pow_apply_eq
theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) {n : ℕ} :
    (f ^ n) a = a ↔ s.card ∣ n 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {a : α} {s : Finset α} (hf : f.IsCycleOn ↑s) (ha : a ∈ s) {n : ℕ}
Goal: (f ^ n) a = a ↔ s.card ∣ n
-- Equiv.Perm.IsCycleOn.zpow_apply_eq
theorem IsCycleOn.zpow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) :
    ∀ {n : ℤ}, (f ^ n) a = a ↔ (s.card : ℤ) ∣ n
  
Arguments: {α : Type u_2} {f : Equiv.Perm α} {a : α} {s : Finset α} (hf : f.IsCycleOn ↑s) (ha : a ∈ s) {n : ℤ}
Goal: (f ^ n) a = a ↔ ↑s.card ∣ n
-- Equiv.Perm.IsCycleOn.pow_apply_eq_pow_apply
theorem IsCycleOn.pow_apply_eq_pow_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s)
    {m n : ℕ} : (f ^ m) a = (f ^ n) a ↔ m ≡ n [MOD s.card] 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {a : α} {s : Finset α} (hf : f.IsCycleOn ↑s) (ha : a ∈ s) {m n : ℕ}
Goal: (f ^ m) a = (f ^ n) a ↔ m ≡ n [MOD s.card]
-- Equiv.Perm.IsCycleOn.zpow_apply_eq_zpow_apply
theorem IsCycleOn.zpow_apply_eq_zpow_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s)
    {m n : ℤ} : (f ^ m) a = (f ^ n) a ↔ m ≡ n [ZMOD s.card] 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {a : α} {s : Finset α} (hf : f.IsCycleOn ↑s) (ha : a ∈ s) {m n : ℤ}
Goal: (f ^ m) a = (f ^ n) a ↔ m ≡ n [ZMOD ↑s.card]
-- Equiv.Perm.IsCycleOn.pow_card_apply
theorem IsCycleOn.pow_card_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) :
    (f ^ s.card) a = a 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {a : α} {s : Finset α} (hf : f.IsCycleOn ↑s) (ha : a ∈ s)
Goal: (f ^ s.card) a = a
-- Equiv.Perm.IsCycleOn.exists_pow_eq
theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
    ∃ n < s.card, (f ^ n) a = b 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {a b : α} {s : Finset α} (hf : f.IsCycleOn ↑s) (ha : a ∈ s) (hb : b ∈ s)
Goal: ∃ n < s.card, (f ^ n) a = b
-- Equiv.Perm.IsCycleOn.exists_pow_eq'
theorem IsCycleOn.exists_pow_eq' (hs : s.Finite) (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
    ∃ n : ℕ, (f ^ n) a = b 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α} {a b : α} (hs : s.Finite) (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s)
Goal: ∃ n, (f ^ n) a = b
-- Equiv.Perm.IsCycleOn.range_pow
theorem IsCycleOn.range_pow (hs : s.Finite) (h : f.IsCycleOn s) (ha : a ∈ s) :
    Set.range (fun n => (f ^ n) a : ℕ → α) = s 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α} {a : α} (hs : s.Finite) (h : f.IsCycleOn s) (ha : a ∈ s)
Goal: (Set.range fun n => (f ^ n) a) = s
-- Equiv.Perm.IsCycleOn.range_zpow
theorem IsCycleOn.range_zpow (h : f.IsCycleOn s) (ha : a ∈ s) :
    Set.range (fun n => (f ^ n) a : ℤ → α) = s 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α} {a : α} (h : f.IsCycleOn s) (ha : a ∈ s)
Goal: (Set.range fun n => (f ^ n) a) = s
-- Equiv.Perm.IsCycleOn.of_pow
theorem IsCycleOn.of_pow {n : ℕ} (hf : (f ^ n).IsCycleOn s) (h : Set.BijOn f s s) : f.IsCycleOn s 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α} {n : ℕ} (hf : (f ^ n).IsCycleOn s) (h : Set.BijOn (⇑f) s s)
Goal: f.IsCycleOn s
-- Equiv.Perm.IsCycleOn.of_zpow
theorem IsCycleOn.of_zpow {n : ℤ} (hf : (f ^ n).IsCycleOn s) (h : Set.BijOn f s s) :
    f.IsCycleOn s 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α} {n : ℤ} (hf : (f ^ n).IsCycleOn s) (h : Set.BijOn (⇑f) s s)
Goal: f.IsCycleOn s
-- Equiv.Perm.IsCycleOn.extendDomain
theorem IsCycleOn.extendDomain {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p)
    (h : g.IsCycleOn s) : (g.extendDomain f).IsCycleOn ((↑) ∘ f '' s) 
Arguments: {α : Type u_2} {β : Type u_3} {g : Equiv.Perm α} {s : Set α} {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) (h : g.IsCycleOn s)
Goal: (g.extendDomain f).IsCycleOn (Subtype.val ∘ ⇑f '' s)
-- Equiv.Perm.IsCycleOn.countable
protected theorem IsCycleOn.countable (hs : f.IsCycleOn s) : s.Countable 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α} (hs : f.IsCycleOn s)
Goal: s.Countable
-- List.Nodup.isCycleOn_formPerm
theorem Nodup.isCycleOn_formPerm (h : l.Nodup) :
    l.formPerm.IsCycleOn { a | a ∈ l } 
Arguments: {α : Type u_2} [DecidableEq α] {l : List α} (h : l.Nodup)
Goal: l.formPerm.IsCycleOn {a | a ∈ l}
-- Finset.exists_cycleOn
theorem exists_cycleOn (s : Finset α) :
    ∃ f : Perm α, f.IsCycleOn s ∧ f.support ⊆ s 
Arguments: {α : Type u_2} [DecidableEq α] [Fintype α] (s : Finset α)
Goal: ∃ f, f.IsCycleOn ↑s ∧ f.support ⊆ s
-- Set.Countable.exists_cycleOn
theorem Countable.exists_cycleOn (hs : s.Countable) :
    ∃ f : Perm α, f.IsCycleOn s ∧ { x | f x ≠ x } ⊆ s 
Arguments: {α : Type u_2} {s : Set α} (hs : s.Countable)
Goal: ∃ f, f.IsCycleOn s ∧ {x | f x ≠ x} ⊆ s
-- Set.prod_self_eq_iUnion_perm
theorem prod_self_eq_iUnion_perm (hf : f.IsCycleOn s) :
    s ×ˢ s = ⋃ n : ℤ, (fun a => (a, (f ^ n) a)) '' s 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Set α} (hf : f.IsCycleOn s)
Goal: s ×ˢ s = ⋃ n, (fun a => (a, (f ^ n) a)) '' s
-- Finset.product_self_eq_disjiUnion_perm_aux
theorem product_self_eq_disjiUnion_perm_aux (hf : f.IsCycleOn s) :
    (range s.card : Set ℕ).PairwiseDisjoint fun k =>
      s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩ 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Finset α} (hf : f.IsCycleOn ↑s)
Goal: (↑(Finset.range s.card)).PairwiseDisjoint fun k => Finset.map { toFun := fun i => (i, (f ^ k) i), inj' := ⋯ } s
-- Finset.product_self_eq_disjiUnion_perm
theorem product_self_eq_disjiUnion_perm (hf : f.IsCycleOn s) :
    s ×ˢ s =
      (range s.card).disjiUnion
        (fun k => s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩)
        (product_self_eq_disjiUnion_perm_aux hf) 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {s : Finset α} (hf : f.IsCycleOn ↑s)
Goal: s ×ˢ s = (Finset.range s.card).disjiUnion (fun k => Finset.map { toFun := fun i => (i, (f ^ k) i), inj' := ⋯ } s) ⋯
-- Finset.sum_smul_sum_eq_sum_perm
theorem sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι → β) :
    (∑ i ∈ s, f i) • ∑ i ∈ s, g i = ∑ k ∈ range s.card, ∑ i ∈ s, f i • g ((σ ^ k) i) 
Arguments: {ι : Type u_1} {α : Type u_2} {β : Type u_3} [Semiring α] [AddCommMonoid β] [Module α β] {s : Finset ι} {σ : Equiv.Perm ι} (hσ : σ.IsCycleOn ↑s) (f : ι → α) (g : ι → β)
Goal: (∑ i ∈ s, f i) • ∑ i ∈ s, g i = ∑ k ∈ Finset.range s.card, ∑ i ∈ s, f i • g ((σ ^ k) i)
-- Finset.sum_mul_sum_eq_sum_perm
theorem sum_mul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f g : ι → α) :
    ((∑ i ∈ s, f i) * ∑ i ∈ s, g i) = ∑ k ∈ range s.card, ∑ i ∈ s, f i * g ((σ ^ k) i) 
Arguments: {ι : Type u_1} {α : Type u_2} [Semiring α] {s : Finset ι} {σ : Equiv.Perm ι} (hσ : σ.IsCycleOn ↑s) (f g : ι → α)
Goal: (∑ i ∈ s, f i) * ∑ i ∈ s, g i = ∑ k ∈ Finset.range s.card, ∑ i ∈ s, f i * g ((σ ^ k) i)
-- Option.id_traverse
theorem Option.id_traverse {α} (x : Option α) : Option.traverse (pure : α → Id α) x = x 
Arguments: {α : Type u_1} (x : Option α)
Goal: Option.traverse pure x = x
-- Option.comp_traverse
theorem Option.comp_traverse {α β γ} (f : β → F γ) (g : α → G β) (x : Option α) :
    Option.traverse (Comp.mk ∘ (f <$> ·) ∘ g) x =
      Comp.mk (Option.traverse f <$> Option.traverse g x) 
Arguments: {F G : Type u → Type u} [Applicative F] [Applicative G] [LawfulApplicative G] {α : Type u_1} {β γ : Type u} (f : β → F γ) (g : α → G β) (x : Option α)
Goal: Option.traverse (Functor.Comp.mk ∘ (fun x => f <$> x) ∘ g) x =
  Functor.Comp.mk (Option.traverse f <$> Option.traverse g x)
-- Option.traverse_eq_map_id
theorem Option.traverse_eq_map_id {α β} (f : α → β) (x : Option α) :
    Option.traverse ((pure : _ → Id _) ∘ f) x = (pure : _ → Id _) (f <$> x) 
Arguments: {α β : Type u_1} (f : α → β) (x : Option α)
Goal: Option.traverse (pure ∘ f) x = pure (f <$> x)
-- Option.naturality
theorem Option.naturality [LawfulApplicative F] {α β} (f : α → F β) (x : Option α) :
    η (Option.traverse f x) = Option.traverse (@η _ ∘ f) x 
Arguments: {F G : Type u → Type u} [Applicative F] [Applicative G] [LawfulApplicative G] (η : ApplicativeTransformation F G) [LawfulApplicative F] {α : Type u_1} {β : Type u} (f : α → F β) (x : Option α)
Goal: (fun {α} => η.app α) (Option.traverse f x) = Option.traverse ((fun {α} => η.app α) ∘ f) x
-- List.id_traverse
protected theorem id_traverse {α} (xs : List α) : List.traverse (pure : α → Id α) xs = xs 
Arguments: {α : Type u_1} (xs : List α)
Goal: List.traverse pure xs = xs
-- List.comp_traverse
protected theorem comp_traverse {α β γ} (f : β → F γ) (g : α → G β) (x : List α) :
    List.traverse (Comp.mk ∘ (f <$> ·) ∘ g) x =
    Comp.mk (List.traverse f <$> List.traverse g x) 
Arguments: {F G : Type u → Type u} [Applicative F] [Applicative G] [LawfulApplicative G] {α : Type u_1} {β γ : Type u} (f : β → F γ) (g : α → G β) (x : List α)
Goal: List.traverse (Functor.Comp.mk ∘ (fun x => f <$> x) ∘ g) x = Functor.Comp.mk (List.traverse f <$> List.traverse g x)
-- List.traverse_eq_map_id
protected theorem traverse_eq_map_id {α β} (f : α → β) (x : List α) :
    List.traverse ((pure : _ → Id _) ∘ f) x = (pure : _ → Id _) (f <$> x) 
Arguments: {α β : Type u_1} (f : α → β) (x : List α)
Goal: List.traverse (pure ∘ f) x = pure (f <$> x)
-- List.naturality
protected theorem naturality {α β} (f : α → F β) (x : List α) :
    η (List.traverse f x) = List.traverse (@η _ ∘ f) x 
Arguments: {F G : Type u → Type u} [Applicative F] [Applicative G] [LawfulApplicative G] [LawfulApplicative F] (η : ApplicativeTransformation F G) {α : Type u_1} {β : Type u} (f : α → F β) (x : List α)
Goal: (fun {α} => η.app α) (List.traverse f x) = List.traverse ((fun {α} => η.app α) ∘ f) x
-- List.traverse_nil
@[simp]
theorem traverse_nil : traverse f ([] : List α') = (pure [] : F (List β')) 
Arguments: {F : Type u → Type u} [Applicative F] {α' β' : Type u} (f : α' → F β')
Goal: traverse f [] = pure []
-- List.traverse_cons
@[simp]
theorem traverse_cons (a : α') (l : List α') :
    traverse f (a :: l) = (· :: ·) <$> f a <*> traverse f l 
Arguments: {F : Type u → Type u} [Applicative F] {α' β' : Type u} (f : α' → F β') (a : α') (l : List α')
Goal: traverse f (a :: l) = Seq.seq ((fun x x_1 => x :: x_1) <$> f a) fun x => traverse f l
-- List.traverse_append
@[simp]
theorem traverse_append :
    ∀ as bs : List α', traverse f (as ++ bs) = (· ++ ·) <$> traverse f as <*> traverse f bs
  
Arguments: {F : Type u → Type u} [Applicative F] {α' β' : Type u} (f : α' → F β') [LawfulApplicative F] (as bs : List α')
Goal: traverse f (as ++ bs) = Seq.seq ((fun x x_1 => x ++ x_1) <$> traverse f as) fun x => traverse f bs
-- List.mem_traverse
theorem mem_traverse {f : α' → Set β'} :
    ∀ (l : List α') (n : List β'), n ∈ traverse f l ↔ Forall₂ (fun b a => b ∈ f a) n l
  
Arguments: {α' β' : Type u} {f : α' → Set β'} (l : List α') (n : List β')
Goal: n ∈ traverse f l ↔ List.Forall₂ (fun b a => b ∈ f a) n l
-- Sum.traverse_map
protected theorem traverse_map {α β γ : Type u} (g : α → β) (f : β → G γ) (x : σ ⊕ α) :
    Sum.traverse f (g <$> x) = Sum.traverse (f ∘ g) x 
Arguments: {σ : Type u} {G : Type u → Type u} [Applicative G] {α β γ : Type u} (g : α → β) (f : β → G γ) (x : σ ⊕ α)
Goal: Sum.traverse f (g <$> x) = Sum.traverse (f ∘ g) x
-- Sum.id_traverse
protected theorem id_traverse {σ α} (x : σ ⊕ α) :
    Sum.traverse (pure : α → Id α) x = x 
Arguments: {σ α : Type u_1} (x : σ ⊕ α)
Goal: Sum.traverse pure x = x
-- Sum.comp_traverse
protected theorem comp_traverse {α β γ : Type u} (f : β → F γ) (g : α → G β) (x : σ ⊕ α) :
    Sum.traverse (Comp.mk ∘ (f <$> ·) ∘ g) x =
    Comp.mk.{u} (Sum.traverse f <$> Sum.traverse g x) 
Arguments: {σ : Type u} {F G : Type u → Type u} [Applicative F] [Applicative G] [LawfulApplicative G] {α β γ : Type u} (f : β → F γ) (g : α → G β) (x : σ ⊕ α)
Goal: Sum.traverse (Functor.Comp.mk ∘ (fun x => f <$> x) ∘ g) x = Functor.Comp.mk (Sum.traverse f <$> Sum.traverse g x)