ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Pi.continuous_curry
theorem continuous_curry : Continuous <| monotoneCurry α β γ 
Arguments: (α : Type u_1) (β : α → Type u_2) (γ : (a : α) → β a → Type u_3) [(x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)]
Goal: OmegaCompletePartialOrder.Continuous (Pi.monotoneCurry α β γ)
-- Pi.continuous_uncurry
theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ 
Arguments: (α : Type u_1) (β : α → Type u_2) (γ : (a : α) → β a → Type u_3) [(x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)]
Goal: OmegaCompletePartialOrder.Continuous (Pi.monotoneUncurry α β γ)
-- Pi.uncurry_curry_continuous
theorem uncurry_curry_continuous (hc : Continuous f) :
    Continuous <| (monotoneUncurry α β γ).comp <| f.comp <| monotoneCurry α β γ 
Arguments: {α : Type u_1} {β : α → Type u_2} {γ : (a : α) → β a → Type u_3} [(x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)] {f : ((x : α) → (y : β x) → γ x y) →o (x : α) → (y : β x) → γ x y} (hc : OmegaCompletePartialOrder.Continuous f)
Goal: OmegaCompletePartialOrder.Continuous ((Pi.monotoneUncurry α β γ).comp (f.comp (Pi.monotoneCurry α β γ)))
-- CoxeterMatrix.isSymm
@[ext]
structure CoxeterMatrix (B : Type*) where
    M : Matrix B B ℕ
  isSymm : M.IsSymm := by decide
  diagonal i : M i i = 1 := by decide
  off_diagonal i i' : i ≠ i' → M i i' ≠ 1 := by decide
Arguments: {B : Type u_1} (self : CoxeterMatrix B)
Goal: self.M.IsSymm
-- CoxeterMatrix.diagonal
@[ext]
structure CoxeterMatrix (B : Type*) where
    M : Matrix B B ℕ
  isSymm : M.IsSymm := by decide
  diagonal i : M i i = 1 := by decide
  off_diagonal i i' : i ≠ i' → M i i' ≠ 1 := by decide
Arguments: {B : Type u_1} (self : CoxeterMatrix B) (i : B)
Goal: self.M i i = 1
-- CoxeterMatrix.off_diagonal
@[ext]
structure CoxeterMatrix (B : Type*) where
    M : Matrix B B ℕ
  isSymm : M.IsSymm := by decide
  diagonal i : M i i = 1 := by decide
  off_diagonal i i' : i ≠ i' → M i i' ≠ 1 := by decide
Arguments: {B : Type u_1} (self : CoxeterMatrix B) (i i' : B)
Goal: i ≠ i' → self.M i i' ≠ 1
-- CoxeterMatrix.symmetric
theorem symmetric (i i' : B) : M i i' = M i' i 
Arguments: {B : Type u_1} (M : CoxeterMatrix B) (i i' : B)
Goal: M.M i i' = M.M i' i
-- CoxeterMatrix.reindex_apply
theorem reindex_apply (i i' : B') : M.reindex e i i' = M (e.symm i) (e.symm i') 
Arguments: {B : Type u_1} {B' : Type u_2} (e : B ≃ B') (M : CoxeterMatrix B) (i i' : B')
Goal: (CoxeterMatrix.reindex e M).M i i' = M.M (e.symm i) (e.symm i')
-- Equiv.Perm.swap_induction_on
@[elab_as_elim]
theorem swap_induction_on [Finite α] {P : Perm α → Prop} (f : Perm α) :
    P 1 → (∀ f x y, x ≠ y → P f → P (swap x y * f)) → P f 
Arguments: {α : Type u} [DecidableEq α] [Finite α] {P : Equiv.Perm α → Prop} (f : Equiv.Perm α)
Goal: P 1 → (∀ (f : Equiv.Perm α) (x y : α), x ≠ y → P f → P (Equiv.swap x y * f)) → P f
-- Equiv.Perm.mclosure_isSwap
theorem mclosure_isSwap [Finite α] : Submonoid.closure { σ : Perm α | IsSwap σ } = ⊤ 
Arguments: {α : Type u} [DecidableEq α] [Finite α]
Goal: Submonoid.closure {σ | σ.IsSwap} = ⊤
-- Equiv.Perm.closure_isSwap
theorem closure_isSwap [Finite α] : Subgroup.closure { σ : Perm α | IsSwap σ } = ⊤ 
Arguments: {α : Type u} [DecidableEq α] [Finite α]
Goal: Subgroup.closure {σ | σ.IsSwap} = ⊤
-- Equiv.Perm.mclosure_swap_castSucc_succ
theorem mclosure_swap_castSucc_succ (n : ℕ) :
    Submonoid.closure (Set.range fun i : Fin n ↦ swap i.castSucc i.succ) = ⊤ 
Arguments: (n : ℕ)
Goal: Submonoid.closure (Set.range fun i => Equiv.swap i.castSucc i.succ) = ⊤
-- Equiv.Perm.swap_induction_on'
@[elab_as_elim]
theorem swap_induction_on' [Finite α] {P : Perm α → Prop} (f : Perm α) :
    P 1 → (∀ f x y, x ≠ y → P f → P (f * swap x y)) → P f 
Arguments: {α : Type u} [DecidableEq α] [Finite α] {P : Equiv.Perm α → Prop} (f : Equiv.Perm α)
Goal: P 1 → (∀ (f : Equiv.Perm α) (x y : α), x ≠ y → P f → P (f * Equiv.swap x y)) → P f
-- Equiv.Perm.isConj_swap
theorem isConj_swap {w x y z : α} (hwx : w ≠ x) (hyz : y ≠ z) : IsConj (swap w x) (swap y z) 
Arguments: {α : Type u} [DecidableEq α] {w x y z : α} (hwx : w ≠ x) (hyz : y ≠ z)
Goal: IsConj (Equiv.swap w x) (Equiv.swap y z)
-- Equiv.Perm.mem_finPairsLT
theorem mem_finPairsLT {n : ℕ} {a : Σ_ : Fin n, Fin n} : a ∈ finPairsLT n ↔ a.2 < a.1 
Arguments: {n : ℕ} {a : (_ : Fin n) × Fin n}
Goal: a ∈ Equiv.Perm.finPairsLT n ↔ a.snd < a.fst
-- Equiv.Perm.signAux_one
@[simp]
theorem signAux_one (n : ℕ) : signAux (1 : Perm (Fin n)) = 1 
Arguments: (n : ℕ)
Goal: Equiv.Perm.signAux 1 = 1
-- Equiv.Perm.signBijAux_injOn
theorem signBijAux_injOn {n : ℕ} {f : Perm (Fin n)} :
    (finPairsLT n : Set (Σ _, Fin n)).InjOn (signBijAux f) 
Arguments: {n : ℕ} {f : Equiv.Perm (Fin n)}
Goal: Set.InjOn f.signBijAux ↑(Equiv.Perm.finPairsLT n)
-- Equiv.Perm.signBijAux_surj
theorem signBijAux_surj {n : ℕ} {f : Perm (Fin n)} :
    ∀ a ∈ finPairsLT n, ∃ b ∈ finPairsLT n, signBijAux f b = a 
Arguments: {n : ℕ} {f : Equiv.Perm (Fin n)} (a : (_ : Fin n) × Fin n)
Goal: a ∈ Equiv.Perm.finPairsLT n → ∃ b ∈ Equiv.Perm.finPairsLT n, f.signBijAux b = a
-- Equiv.Perm.signBijAux_mem
theorem signBijAux_mem {n : ℕ} {f : Perm (Fin n)} :
    ∀ a : Σ_ : Fin n, Fin n, a ∈ finPairsLT n → signBijAux f a ∈ finPairsLT n 
Arguments: {n : ℕ} {f : Equiv.Perm (Fin n)} (a : (_ : Fin n) × Fin n)
Goal: a ∈ Equiv.Perm.finPairsLT n → f.signBijAux a ∈ Equiv.Perm.finPairsLT n
-- Equiv.Perm.signAux_inv
@[simp]
theorem signAux_inv {n : ℕ} (f : Perm (Fin n)) : signAux f⁻¹ = signAux f 
Arguments: {n : ℕ} (f : Equiv.Perm (Fin n))
Goal: f⁻¹.signAux = f.signAux
-- Equiv.Perm.signAux_mul
theorem signAux_mul {n : ℕ} (f g : Perm (Fin n)) : signAux (f * g) = signAux f * signAux g 
Arguments: {n : ℕ} (f g : Equiv.Perm (Fin n))
Goal: (f * g).signAux = f.signAux * g.signAux
-- _private.Mathlib.GroupTheory.Perm.Sign.0.Equiv.Perm.signAux_swap_zero_one'
private theorem signAux_swap_zero_one' (n : ℕ) : signAux (swap (0 : Fin (n + 2)) 1) = -1 
Arguments: (n : ℕ)
Goal: (Equiv.swap 0 1).signAux = -1
-- _private.Mathlib.GroupTheory.Perm.Sign.0.Equiv.Perm.signAux_swap_zero_one
private theorem signAux_swap_zero_one {n : ℕ} (hn : 2 ≤ n) :
    signAux (swap (⟨0, lt_of_lt_of_le (by decide) hn⟩ : Fin n) ⟨1, lt_of_lt_of_le (by decide) hn⟩) =
      -1 
Arguments: {n : ℕ} (hn : 2 ≤ n)
Goal: (Equiv.swap ⟨0, ⋯⟩ ⟨1, ⋯⟩).signAux = -1
-- Equiv.Perm.signAux_swap
theorem signAux_swap : ∀ {n : ℕ} {x y : Fin n} (_hxy : x ≠ y), signAux (swap x y) = -1
  
Arguments: {n : ℕ} {x y : Fin n} (_hxy : x ≠ y)
Goal: (Equiv.swap x y).signAux = -1
-- Equiv.Perm.signAux_eq_signAux2
theorem signAux_eq_signAux2 {n : ℕ} :
    ∀ (l : List α) (f : Perm α) (e : α ≃ Fin n) (_h : ∀ x, f x ≠ x → x ∈ l),
      signAux ((e.symm.trans f).trans e) = signAux2 l f
  
Arguments: {α : Type u} [DecidableEq α] {n : ℕ} (l : List α) (f : Equiv.Perm α) (e : α ≃ Fin n) (_h : ∀ (x : α), f x ≠ x → x ∈ l)
Goal: Equiv.Perm.signAux ((e.symm.trans f).trans e) = Equiv.Perm.signAux2 l f
-- Equiv.Perm.signAux3_mul_and_swap
theorem signAux3_mul_and_swap [Finite α] (f g : Perm α) (s : Multiset α) (hs : ∀ x, x ∈ s) :
    signAux3 (f * g) hs = signAux3 f hs * signAux3 g hs ∧
      Pairwise fun x y => signAux3 (swap x y) hs = -1 
Arguments: {α : Type u} [DecidableEq α] [Finite α] (f g : Equiv.Perm α) (s : Multiset α) (hs : ∀ (x : α), x ∈ s)
Goal: (f * g).signAux3 hs = f.signAux3 hs * g.signAux3 hs ∧ Pairwise fun x y => (Equiv.swap x y).signAux3 hs = -1
-- Equiv.Perm.signAux3_symm_trans_trans
theorem signAux3_symm_trans_trans [Finite α] [DecidableEq β] [Finite β] (f : Perm α) (e : α ≃ β)
    {s : Multiset α} {t : Multiset β} (hs : ∀ x, x ∈ s) (ht : ∀ x, x ∈ t) :
    signAux3 ((e.symm.trans f).trans e) ht = signAux3 f hs 
Arguments: {α : Type u} [DecidableEq α] {β : Type v} [Finite α] [DecidableEq β] [Finite β] (f : Equiv.Perm α) (e : α ≃ β) {s : Multiset α} {t : Multiset β} (hs : ∀ (x : α), x ∈ s) (ht : ∀ (x : β), x ∈ t)
Goal: Equiv.Perm.signAux3 ((e.symm.trans f).trans e) ht = f.signAux3 hs
-- Equiv.Perm.sign_mul
theorem sign_mul (f g : Perm α) : sign (f * g) = sign f * sign g 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] (f g : Equiv.Perm α)
Goal: Equiv.Perm.sign (f * g) = Equiv.Perm.sign f * Equiv.Perm.sign g
-- Equiv.Perm.sign_trans
@[simp]
theorem sign_trans (f g : Perm α) : sign (f.trans g) = sign g * sign f 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] (f g : Equiv.Perm α)
Goal: Equiv.Perm.sign (Equiv.trans f g) = Equiv.Perm.sign g * Equiv.Perm.sign f
-- Equiv.Perm.sign_one
theorem sign_one : sign (1 : Perm α) = 1 
Arguments: {α : Type u} [DecidableEq α] [Fintype α]
Goal: Equiv.Perm.sign 1 = 1
-- Equiv.Perm.sign_refl
@[simp]
theorem sign_refl : sign (Equiv.refl α) = 1 
Arguments: {α : Type u} [DecidableEq α] [Fintype α]
Goal: Equiv.Perm.sign (Equiv.refl α) = 1
-- Equiv.Perm.sign_inv
theorem sign_inv (f : Perm α) : sign f⁻¹ = sign f 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] (f : Equiv.Perm α)
Goal: Equiv.Perm.sign f⁻¹ = Equiv.Perm.sign f
-- Equiv.Perm.sign_symm
@[simp]
theorem sign_symm (e : Perm α) : sign e.symm = sign e 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] (e : Equiv.Perm α)
Goal: Equiv.Perm.sign (Equiv.symm e) = Equiv.Perm.sign e
-- Equiv.Perm.sign_swap
theorem sign_swap {x y : α} (h : x ≠ y) : sign (swap x y) = -1 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] {x y : α} (h : x ≠ y)
Goal: Equiv.Perm.sign (Equiv.swap x y) = -1
-- Equiv.Perm.sign_swap'
@[simp]
theorem sign_swap' {x y : α} : sign (swap x y) = if x = y then 1 else -1 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] {x y : α}
Goal: Equiv.Perm.sign (Equiv.swap x y) = if x = y then 1 else -1
-- Equiv.Perm.IsSwap.sign_eq
theorem IsSwap.sign_eq {f : Perm α} (h : f.IsSwap) : sign f = -1 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] {f : Equiv.Perm α} (h : f.IsSwap)
Goal: Equiv.Perm.sign f = -1
-- Equiv.Perm.sign_symm_trans_trans
@[simp]
theorem sign_symm_trans_trans [DecidableEq β] [Fintype β] (f : Perm α) (e : α ≃ β) :
    sign ((e.symm.trans f).trans e) = sign f 
Arguments: {α : Type u} [DecidableEq α] {β : Type v} [Fintype α] [DecidableEq β] [Fintype β] (f : Equiv.Perm α) (e : α ≃ β)
Goal: Equiv.Perm.sign ((e.symm.trans f).trans e) = Equiv.Perm.sign f
-- Equiv.Perm.sign_trans_trans_symm
@[simp]
theorem sign_trans_trans_symm [DecidableEq β] [Fintype β] (f : Perm β) (e : α ≃ β) :
    sign ((e.trans f).trans e.symm) = sign f 
Arguments: {α : Type u} [DecidableEq α] {β : Type v} [Fintype α] [DecidableEq β] [Fintype β] (f : Equiv.Perm β) (e : α ≃ β)
Goal: Equiv.Perm.sign ((e.trans f).trans e.symm) = Equiv.Perm.sign f
-- Equiv.Perm.sign_prod_list_swap
theorem sign_prod_list_swap {l : List (Perm α)} (hl : ∀ g ∈ l, IsSwap g) :
    sign l.prod = (-1) ^ l.length 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] {l : List (Equiv.Perm α)} (hl : ∀ g ∈ l, g.IsSwap)
Goal: Equiv.Perm.sign l.prod = (-1) ^ l.length
-- Equiv.Perm.sign_abs
@[simp]
theorem sign_abs (f : Perm α) :
    |(Equiv.Perm.sign f : ℤ)| = 1 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] (f : Equiv.Perm α)
Goal: |↑(Equiv.Perm.sign f)| = 1
-- Equiv.Perm.sign_surjective
theorem sign_surjective [Nontrivial α] : Function.Surjective (sign : Perm α → ℤˣ) 
Arguments: (α : Type u) [DecidableEq α] [Fintype α] [Nontrivial α]
Goal: Function.Surjective ⇑Equiv.Perm.sign
-- Equiv.Perm.eq_sign_of_surjective_hom
theorem eq_sign_of_surjective_hom {s : Perm α →* ℤˣ} (hs : Surjective s) : s = sign 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] {s : Equiv.Perm α →* ℤˣ} (hs : Function.Surjective ⇑s)
Goal: s = Equiv.Perm.sign
-- Equiv.Perm.sign_subtypePerm
theorem sign_subtypePerm (f : Perm α) {p : α → Prop} [DecidablePred p] (h₁ : ∀ x, p x ↔ p (f x))
    (h₂ : ∀ x, f x ≠ x → p x) : sign (subtypePerm f h₁) = sign f 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] (f : Equiv.Perm α) {p : α → Prop} [DecidablePred p] (h₁ : ∀ (x : α), p x ↔ p (f x)) (h₂ : ∀ (x : α), f x ≠ x → p x)
Goal: Equiv.Perm.sign (f.subtypePerm h₁) = Equiv.Perm.sign f
-- Equiv.Perm.sign_eq_sign_of_equiv
theorem sign_eq_sign_of_equiv [DecidableEq β] [Fintype β] (f : Perm α) (g : Perm β) (e : α ≃ β)
    (h : ∀ x, e (f x) = g (e x)) : sign f = sign g 
Arguments: {α : Type u} [DecidableEq α] {β : Type v} [Fintype α] [DecidableEq β] [Fintype β] (f : Equiv.Perm α) (g : Equiv.Perm β) (e : α ≃ β) (h : ∀ (x : α), e (f x) = g (e x))
Goal: Equiv.Perm.sign f = Equiv.Perm.sign g
-- Equiv.Perm.sign_bij
theorem sign_bij [DecidableEq β] [Fintype β] {f : Perm α} {g : Perm β} (i : ∀ x : α, f x ≠ x → β)
    (h : ∀ x hx hx', i (f x) hx' = g (i x hx)) (hi : ∀ x₁ x₂ hx₁ hx₂, i x₁ hx₁ = i x₂ hx₂ → x₁ = x₂)
    (hg : ∀ y, g y ≠ y → ∃ x hx, i x hx = y) : sign f = sign g 
Arguments: {α : Type u} [DecidableEq α] {β : Type v} [Fintype α] [DecidableEq β] [Fintype β] {f : Equiv.Perm α} {g : Equiv.Perm β} (i : (x : α) → f x ≠ x → β) (h : ∀ (x : α) (hx : f x ≠ x) (hx' : f (f x) ≠ f x), i (f x) hx' = g (i x hx)) (hi : ∀ (x₁ x₂ : α) (hx₁ : f x₁ ≠ x₁) (hx₂ : f x₂ ≠ x₂), i x₁ hx₁ = i x₂ hx₂ → x₁ = x₂) (hg : ∀ (y : β), g y ≠ y → ∃ x, ∃ (hx : f x ≠ x), i x hx = y)
Goal: Equiv.Perm.sign f = Equiv.Perm.sign g
-- Equiv.Perm.prod_prodExtendRight
theorem prod_prodExtendRight {α : Type*} [DecidableEq α] (σ : α → Perm β) {l : List α}
    (hl : l.Nodup) (mem_l : ∀ a, a ∈ l) :
    (l.map fun a => prodExtendRight a (σ a)).prod = prodCongrRight σ 
Arguments: {β : Type v} {α : Type u_1} [DecidableEq α] (σ : α → Equiv.Perm β) {l : List α} (hl : l.Nodup) (mem_l : ∀ (a : α), a ∈ l)
Goal: (List.map (fun a => Equiv.Perm.prodExtendRight a (σ a)) l).prod = Equiv.prodCongrRight σ
-- Equiv.Perm.sign_prodExtendRight
@[simp]
theorem sign_prodExtendRight (a : α) (σ : Perm β) : sign (prodExtendRight a σ) = sign σ 
Arguments: {α : Type u} [DecidableEq α] {β : Type v} [Fintype α] [DecidableEq β] [Fintype β] (a : α) (σ : Equiv.Perm β)
Goal: Equiv.Perm.sign (Equiv.Perm.prodExtendRight a σ) = Equiv.Perm.sign σ
-- Equiv.Perm.sign_prodCongrRight
theorem sign_prodCongrRight (σ : α → Perm β) : sign (prodCongrRight σ) = ∏ k, sign (σ k) 
Arguments: {α : Type u} [DecidableEq α] {β : Type v} [Fintype α] [DecidableEq β] [Fintype β] (σ : α → Equiv.Perm β)
Goal: Equiv.Perm.sign (Equiv.prodCongrRight σ) = ∏ k : α, Equiv.Perm.sign (σ k)
-- Equiv.Perm.sign_prodCongrLeft
theorem sign_prodCongrLeft (σ : α → Perm β) : sign (prodCongrLeft σ) = ∏ k, sign (σ k) 
Arguments: {α : Type u} [DecidableEq α] {β : Type v} [Fintype α] [DecidableEq β] [Fintype β] (σ : α → Equiv.Perm β)
Goal: Equiv.Perm.sign (Equiv.prodCongrLeft σ) = ∏ k : α, Equiv.Perm.sign (σ k)
-- Equiv.Perm.sign_permCongr
@[simp]
theorem sign_permCongr (e : α ≃ β) (p : Perm α) : sign (e.permCongr p) = sign p 
Arguments: {α : Type u} [DecidableEq α] {β : Type v} [Fintype α] [DecidableEq β] [Fintype β] (e : α ≃ β) (p : Equiv.Perm α)
Goal: Equiv.Perm.sign (e.permCongr p) = Equiv.Perm.sign p
-- Equiv.Perm.sign_sumCongr
@[simp]
theorem sign_sumCongr (σa : Perm α) (σb : Perm β) : sign (sumCongr σa σb) = sign σa * sign σb 
Arguments: {α : Type u} [DecidableEq α] {β : Type v} [Fintype α] [DecidableEq β] [Fintype β] (σa : Equiv.Perm α) (σb : Equiv.Perm β)
Goal: Equiv.Perm.sign (σa.sumCongr σb) = Equiv.Perm.sign σa * Equiv.Perm.sign σb
-- Equiv.Perm.sign_subtypeCongr
@[simp]
theorem sign_subtypeCongr {p : α → Prop} [DecidablePred p] (ep : Perm { a // p a })
    (en : Perm { a // ¬p a }) : sign (ep.subtypeCongr en) = sign ep * sign en 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] {p : α → Prop} [DecidablePred p] (ep : Equiv.Perm { a // p a }) (en : Equiv.Perm { a // ¬p a })
Goal: Equiv.Perm.sign (ep.subtypeCongr en) = Equiv.Perm.sign ep * Equiv.Perm.sign en
-- Equiv.Perm.sign_extendDomain
@[simp]
theorem sign_extendDomain (e : Perm α) {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) :
    Equiv.Perm.sign (e.extendDomain f) = Equiv.Perm.sign e 
Arguments: {α : Type u} [DecidableEq α] {β : Type v} [Fintype α] [DecidableEq β] [Fintype β] (e : Equiv.Perm α) {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p)
Goal: Equiv.Perm.sign (e.extendDomain f) = Equiv.Perm.sign e
-- Equiv.Perm.sign_ofSubtype
@[simp]
theorem sign_ofSubtype {p : α → Prop} [DecidablePred p] (f : Equiv.Perm (Subtype p)) :
    sign (ofSubtype f) = sign f 
Arguments: {α : Type u} [DecidableEq α] [Fintype α] {p : α → Prop} [DecidablePred p] (f : Equiv.Perm (Subtype p))
Goal: Equiv.Perm.sign (Equiv.Perm.ofSubtype f) = Equiv.Perm.sign f
-- Equiv.Perm.SameCycle.refl
@[refl]
theorem SameCycle.refl (f : Perm α) (x : α) : SameCycle f x x 
Arguments: {α : Type u_2} (f : Equiv.Perm α) (x : α)
Goal: f.SameCycle x x
-- Equiv.Perm.SameCycle.rfl
theorem SameCycle.rfl : SameCycle f x x 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x : α}
Goal: f.SameCycle x x
-- Eq.sameCycle
protected theorem _root_.Eq.sameCycle (h : x = y) (f : Perm α) : f.SameCycle x y 
Arguments: {α : Type u_2} {x y : α} (h : x = y) (f : Equiv.Perm α)
Goal: f.SameCycle x y
-- Equiv.Perm.SameCycle.symm
@[symm]
theorem SameCycle.symm : SameCycle f x y → SameCycle f y x 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α}
Goal: f.SameCycle x y → f.SameCycle y x
-- Equiv.Perm.sameCycle_comm
theorem sameCycle_comm : SameCycle f x y ↔ SameCycle f y x 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α}
Goal: f.SameCycle x y ↔ f.SameCycle y x
-- Equiv.Perm.SameCycle.trans
@[trans]
theorem SameCycle.trans : SameCycle f x y → SameCycle f y z → SameCycle f x z 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y z : α}
Goal: f.SameCycle x y → f.SameCycle y z → f.SameCycle x z
-- Equiv.Perm.SameCycle.equivalence
theorem SameCycle.equivalence : Equivalence (SameCycle f) 
Arguments: {α : Type u_2} (f : Equiv.Perm α)
Goal: Equivalence f.SameCycle
-- Equiv.Perm.sameCycle_one
@[simp]
theorem sameCycle_one : SameCycle 1 x y ↔ x = y 
Arguments: {α : Type u_2} {x y : α}
Goal: Equiv.Perm.SameCycle 1 x y ↔ x = y
-- Equiv.Perm.sameCycle_inv
@[simp]
theorem sameCycle_inv : SameCycle f⁻¹ x y ↔ SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α}
Goal: f⁻¹.SameCycle x y ↔ f.SameCycle x y
-- Equiv.Perm.sameCycle_conj
@[simp]
theorem sameCycle_conj : SameCycle (g * f * g⁻¹) x y ↔ SameCycle f (g⁻¹ x) (g⁻¹ y) 
Arguments: {α : Type u_2} {f g : Equiv.Perm α} {x y : α}
Goal: (g * f * g⁻¹).SameCycle x y ↔ f.SameCycle (g⁻¹ x) (g⁻¹ y)
-- Equiv.Perm.SameCycle.conj
theorem SameCycle.conj : SameCycle f x y → SameCycle (g * f * g⁻¹) (g x) (g y) 
Arguments: {α : Type u_2} {f g : Equiv.Perm α} {x y : α}
Goal: f.SameCycle x y → (g * f * g⁻¹).SameCycle (g x) (g y)
-- Equiv.Perm.SameCycle.apply_eq_self_iff
theorem SameCycle.apply_eq_self_iff : SameCycle f x y → (f x = x ↔ f y = y) 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α}
Goal: f.SameCycle x y → (f x = x ↔ f y = y)
-- Equiv.Perm.SameCycle.eq_of_left
theorem SameCycle.eq_of_left (h : SameCycle f x y) (hx : IsFixedPt f x) : x = y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} (h : f.SameCycle x y) (hx : Function.IsFixedPt (⇑f) x)
Goal: x = y
-- Equiv.Perm.SameCycle.eq_of_right
theorem SameCycle.eq_of_right (h : SameCycle f x y) (hy : IsFixedPt f y) : x = y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} (h : f.SameCycle x y) (hy : Function.IsFixedPt (⇑f) y)
Goal: x = y
-- Equiv.Perm.sameCycle_apply_left
@[simp]
theorem sameCycle_apply_left : SameCycle f (f x) y ↔ SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α}
Goal: f.SameCycle (f x) y ↔ f.SameCycle x y
-- Equiv.Perm.sameCycle_apply_right
@[simp]
theorem sameCycle_apply_right : SameCycle f x (f y) ↔ SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α}
Goal: f.SameCycle x (f y) ↔ f.SameCycle x y
-- Equiv.Perm.sameCycle_inv_apply_left
@[simp]
theorem sameCycle_inv_apply_left : SameCycle f (f⁻¹ x) y ↔ SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α}
Goal: f.SameCycle (f⁻¹ x) y ↔ f.SameCycle x y
-- Equiv.Perm.sameCycle_inv_apply_right
@[simp]
theorem sameCycle_inv_apply_right : SameCycle f x (f⁻¹ y) ↔ SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α}
Goal: f.SameCycle x (f⁻¹ y) ↔ f.SameCycle x y
-- Equiv.Perm.sameCycle_zpow_left
@[simp]
theorem sameCycle_zpow_left {n : ℤ} : SameCycle f ((f ^ n) x) y ↔ SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℤ}
Goal: f.SameCycle ((f ^ n) x) y ↔ f.SameCycle x y
-- Equiv.Perm.sameCycle_zpow_right
@[simp]
theorem sameCycle_zpow_right {n : ℤ} : SameCycle f x ((f ^ n) y) ↔ SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℤ}
Goal: f.SameCycle x ((f ^ n) y) ↔ f.SameCycle x y
-- Equiv.Perm.sameCycle_pow_left
@[simp]
theorem sameCycle_pow_left {n : ℕ} : SameCycle f ((f ^ n) x) y ↔ SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℕ}
Goal: f.SameCycle ((f ^ n) x) y ↔ f.SameCycle x y
-- Equiv.Perm.sameCycle_pow_right
@[simp]
theorem sameCycle_pow_right {n : ℕ} : SameCycle f x ((f ^ n) y) ↔ SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℕ}
Goal: f.SameCycle x ((f ^ n) y) ↔ f.SameCycle x y
-- Equiv.Perm.SameCycle.of_pow
theorem SameCycle.of_pow {n : ℕ} : SameCycle (f ^ n) x y → SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℕ}
Goal: (f ^ n).SameCycle x y → f.SameCycle x y
-- Equiv.Perm.SameCycle.of_zpow
theorem SameCycle.of_zpow {n : ℤ} : SameCycle (f ^ n) x y → SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℤ}
Goal: (f ^ n).SameCycle x y → f.SameCycle x y
-- Equiv.Perm.sameCycle_subtypePerm
@[simp]
theorem sameCycle_subtypePerm {h} {x y : { x // p x }} :
    (f.subtypePerm h).SameCycle x y ↔ f.SameCycle x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {p : α → Prop} {h : ∀ (x : α), p x ↔ p (f x)} {x y : { x // p x }}
Goal: (f.subtypePerm h).SameCycle x y ↔ f.SameCycle ↑x ↑y
-- Equiv.Perm.sameCycle_extendDomain
@[simp]
theorem sameCycle_extendDomain {p : β → Prop} [DecidablePred p] {f : α ≃ Subtype p} :
    SameCycle (g.extendDomain f) (f x) (f y) ↔ g.SameCycle x y 
Arguments: {α : Type u_2} {β : Type u_3} {g : Equiv.Perm α} {x y : α} {p : β → Prop} [DecidablePred p] {f : α ≃ Subtype p}
Goal: (g.extendDomain f).SameCycle ↑(f x) ↑(f y) ↔ g.SameCycle x y
-- Equiv.Perm.SameCycle.exists_pow_eq'
theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < orderOf f, (f ^ i) x = y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} [Finite α]
Goal: f.SameCycle x y → ∃ i < orderOf f, (f ^ i) x = y
-- Equiv.Perm.SameCycle.exists_pow_eq''
theorem SameCycle.exists_pow_eq'' [Finite α] (h : SameCycle f x y) :
    ∃ i : ℕ, 0 < i ∧ i ≤ orderOf f ∧ (f ^ i) x = y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} [Finite α] (h : f.SameCycle x y)
Goal: ∃ i, 0 < i ∧ i ≤ orderOf f ∧ (f ^ i) x = y
-- Equiv.Perm.IsCycle.ne_one
theorem IsCycle.ne_one (h : IsCycle f) : f ≠ 1 
Arguments: {α : Type u_2} {f : Equiv.Perm α} (h : f.IsCycle)
Goal: f ≠ 1
-- Equiv.Perm.not_isCycle_one
@[simp]
theorem not_isCycle_one : ¬(1 : Perm α).IsCycle 
Arguments: {α : Type u_2}
Goal: ¬Equiv.Perm.IsCycle 1
-- Equiv.Perm.IsCycle.sameCycle
protected theorem IsCycle.sameCycle (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y) :
    SameCycle f x y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α} (hf : f.IsCycle) (hx : f x ≠ x) (hy : f y ≠ y)
Goal: f.SameCycle x y
-- Equiv.Perm.IsCycle.exists_zpow_eq
theorem IsCycle.exists_zpow_eq : IsCycle f → f x ≠ x → f y ≠ y → ∃ i : ℤ, (f ^ i) x = y 
Arguments: {α : Type u_2} {f : Equiv.Perm α} {x y : α}
Goal: f.IsCycle → f x ≠ x → f y ≠ y → ∃ i, (f ^ i) x = y
-- Equiv.Perm.IsCycle.inv
theorem IsCycle.inv (hf : IsCycle f) : IsCycle f⁻¹ 
Arguments: {α : Type u_2} {f : Equiv.Perm α} (hf : f.IsCycle)
Goal: f⁻¹.IsCycle
-- Equiv.Perm.isCycle_inv
@[simp]
theorem isCycle_inv : IsCycle f⁻¹ ↔ IsCycle f 
Arguments: {α : Type u_2} {f : Equiv.Perm α}
Goal: f⁻¹.IsCycle ↔ f.IsCycle
-- Equiv.Perm.IsCycle.conj
theorem IsCycle.conj : IsCycle f → IsCycle (g * f * g⁻¹) 
Arguments: {α : Type u_2} {f g : Equiv.Perm α}
Goal: f.IsCycle → (g * f * g⁻¹).IsCycle
-- Equiv.Perm.IsCycle.extendDomain
protected theorem IsCycle.extendDomain {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) :
    IsCycle g → IsCycle (g.extendDomain f) 
Arguments: {α : Type u_2} {β : Type u_3} {g : Equiv.Perm α} {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p)
Goal: g.IsCycle → (g.extendDomain f).IsCycle