ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- StarRingEquiv.trans_apply
@[simp]
theorem trans_apply (e₁ : A ≃⋆+* B) (e₂ : B ≃⋆+* C) (x : A) : (e₁.trans e₂) x = e₂ (e₁ x) 
Arguments: {A : Type u_1} {B : Type u_2} {C : Type u_3} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] [Add C] [Mul C] [Star C] (e₁ : A ≃⋆+* B) (e₂ : B ≃⋆+* C) (x : A)
Goal: (e₁.trans e₂) x = e₂ (e₁ x)
-- StarRingEquiv.leftInverse_symm
theorem leftInverse_symm (e : A ≃⋆+* B) : Function.LeftInverse e.symm e 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (e : A ≃⋆+* B)
Goal: Function.LeftInverse ⇑e.symm ⇑e
-- StarRingEquiv.rightInverse_symm
theorem rightInverse_symm (e : A ≃⋆+* B) : Function.RightInverse e.symm e 
Arguments: {A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (e : A ≃⋆+* B)
Goal: Function.RightInverse ⇑e.symm ⇑e
-- StarRingEquiv.ofStarRingHom_symm_apply
@[simps]
def ofStarRingHom (f : F) (g : G) (h₁ : ∀ x, g (f x) = x) (h₂ : ∀ x, f (g x) = x) : A ≃⋆+* B 
Arguments: {F : Type u_1} {G : Type u_2} {A : Type u_3} {B : Type u_4} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] [FunLike F A B] [NonUnitalRingHomClass F A B] [NonUnitalStarRingHomClass F A B] [FunLike G B A] (f : F) (g : G) (h₁ : ∀ (x : A), g (f x) = x) (h₂ : ∀ (x : B), f (g x) = x) (a : B)
Goal: (StarRingEquiv.ofStarRingHom f g h₁ h₂).symm a = g a
-- StarRingEquiv.ofStarRingHom_apply
@[simps]
def ofStarRingHom (f : F) (g : G) (h₁ : ∀ x, g (f x) = x) (h₂ : ∀ x, f (g x) = x) : A ≃⋆+* B 
Arguments: {F : Type u_1} {G : Type u_2} {A : Type u_3} {B : Type u_4} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] [FunLike F A B] [NonUnitalRingHomClass F A B] [NonUnitalStarRingHomClass F A B] [FunLike G B A] (f : F) (g : G) (h₁ : ∀ (x : A), g (f x) = x) (h₂ : ∀ (x : B), f (g x) = x) (a : A)
Goal: (StarRingEquiv.ofStarRingHom f g h₁ h₂) a = f a
-- StarRingEquiv.coe_ofBijective
@[simp]
theorem coe_ofBijective {f : F} (hf : Function.Bijective f) :
    (StarRingEquiv.ofBijective f hf : A → B) = f 
Arguments: {F : Type u_1} {A : Type u_3} {B : Type u_4} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] [FunLike F A B] [NonUnitalRingHomClass F A B] [NonUnitalStarRingHomClass F A B] {f : F} (hf : Function.Bijective ⇑f)
Goal: ⇑(StarRingEquiv.ofBijective f hf) = ⇑f
-- StarRingEquiv.ofBijective_apply
theorem ofBijective_apply {f : F} (hf : Function.Bijective f) (a : A) :
    (StarRingEquiv.ofBijective f hf) a = f a 
Arguments: {F : Type u_1} {A : Type u_3} {B : Type u_4} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] [FunLike F A B] [NonUnitalRingHomClass F A B] [NonUnitalStarRingHomClass F A B] {f : F} (hf : Function.Bijective ⇑f) (a : A)
Goal: (StarRingEquiv.ofBijective f hf) a = f a
-- Set.star_empty
@[simp]
theorem star_empty [Star α] : (∅ : Set α)⋆ = ∅ 
Arguments: {α : Type u_1} [Star α]
Goal: star ∅ = ∅
-- Set.star_univ
@[simp]
theorem star_univ [Star α] : (univ : Set α)⋆ = univ 
Arguments: {α : Type u_1} [Star α]
Goal: star Set.univ = Set.univ
-- Set.nonempty_star
@[simp]
theorem nonempty_star [InvolutiveStar α] {s : Set α} : s⋆.Nonempty ↔ s.Nonempty 
Arguments: {α : Type u_1} [InvolutiveStar α] {s : Set α}
Goal: (star s).Nonempty ↔ s.Nonempty
-- Set.Nonempty.star
theorem Nonempty.star [InvolutiveStar α] {s : Set α} (h : s.Nonempty) : s⋆.Nonempty 
Arguments: {α : Type u_1} [InvolutiveStar α] {s : Set α} (h : s.Nonempty)
Goal: (star s).Nonempty
-- Set.mem_star
@[simp]
theorem mem_star [Star α] : a ∈ s⋆ ↔ a⋆ ∈ s 
Arguments: {α : Type u_1} {s : Set α} {a : α} [Star α]
Goal: a ∈ star s ↔ star a ∈ s
-- Set.star_mem_star
theorem star_mem_star [InvolutiveStar α] : a⋆ ∈ s⋆ ↔ a ∈ s 
Arguments: {α : Type u_1} {s : Set α} {a : α} [InvolutiveStar α]
Goal: star a ∈ star s ↔ a ∈ s
-- Set.star_preimage
@[simp]
theorem star_preimage [Star α] : Star.star ⁻¹' s = s⋆ 
Arguments: {α : Type u_1} {s : Set α} [Star α]
Goal: star ⁻¹' s = star s
-- Set.image_star
@[simp]
theorem image_star [InvolutiveStar α] : Star.star '' s = s⋆ 
Arguments: {α : Type u_1} {s : Set α} [InvolutiveStar α]
Goal: star '' s = star s
-- Set.inter_star
@[simp]
theorem inter_star [Star α] : (s ∩ t)⋆ = s⋆ ∩ t⋆ 
Arguments: {α : Type u_1} {s t : Set α} [Star α]
Goal: star (s ∩ t) = star s ∩ star t
-- Set.union_star
@[simp]
theorem union_star [Star α] : (s ∪ t)⋆ = s⋆ ∪ t⋆ 
Arguments: {α : Type u_1} {s t : Set α} [Star α]
Goal: star (s ∪ t) = star s ∪ star t
-- Set.iInter_star
@[simp]
theorem iInter_star {ι : Sort*} [Star α] (s : ι → Set α) : (⋂ i, s i)⋆ = ⋂ i, (s i)⋆ 
Arguments: {α : Type u_1} {ι : Sort u_2} [Star α] (s : ι → Set α)
Goal: star (⋂ i, s i) = ⋂ i, star (s i)
-- Set.iUnion_star
@[simp]
theorem iUnion_star {ι : Sort*} [Star α] (s : ι → Set α) : (⋃ i, s i)⋆ = ⋃ i, (s i)⋆ 
Arguments: {α : Type u_1} {ι : Sort u_2} [Star α] (s : ι → Set α)
Goal: star (⋃ i, s i) = ⋃ i, star (s i)
-- Set.compl_star
@[simp]
theorem compl_star [Star α] : sᶜ⋆ = s⋆ᶜ 
Arguments: {α : Type u_1} {s : Set α} [Star α]
Goal: star sᶜ = (star s)ᶜ
-- Set.star_subset_star
@[simp]
theorem star_subset_star [InvolutiveStar α] {s t : Set α} : s⋆ ⊆ t⋆ ↔ s ⊆ t 
Arguments: {α : Type u_1} [InvolutiveStar α] {s t : Set α}
Goal: star s ⊆ star t ↔ s ⊆ t
-- Set.star_subset
theorem star_subset [InvolutiveStar α] {s t : Set α} : s⋆ ⊆ t ↔ s ⊆ t⋆ 
Arguments: {α : Type u_1} [InvolutiveStar α] {s t : Set α}
Goal: star s ⊆ t ↔ s ⊆ star t
-- Set.Finite.star
theorem Finite.star [InvolutiveStar α] {s : Set α} (hs : s.Finite) : s⋆.Finite 
Arguments: {α : Type u_1} [InvolutiveStar α] {s : Set α} (hs : s.Finite)
Goal: (star s).Finite
-- Set.star_singleton
theorem star_singleton {β : Type*} [InvolutiveStar β] (x : β) : ({x} : Set β)⋆ = {x⋆} 
Arguments: {β : Type u_2} [InvolutiveStar β] (x : β)
Goal: star {x} = {star x}
-- Set.star_mul
protected theorem star_mul [Mul α] [StarMul α] (s t : Set α) : (s * t)⋆ = t⋆ * s⋆ 
Arguments: {α : Type u_1} [Mul α] [StarMul α] (s t : Set α)
Goal: star (s * t) = star t * star s
-- Set.star_add
protected theorem star_add [AddMonoid α] [StarAddMonoid α] (s t : Set α) : (s + t)⋆ = s⋆ + t⋆ 
Arguments: {α : Type u_1} [AddMonoid α] [StarAddMonoid α] (s t : Set α)
Goal: star (s + t) = star s + star t
-- Set.star_inv
protected theorem star_inv [Group α] [StarMul α] (s : Set α) : s⁻¹⋆ = s⋆⁻¹ 
Arguments: {α : Type u_1} [Group α] [StarMul α] (s : Set α)
Goal: star s⁻¹ = (star s)⁻¹
-- Set.star_inv'
protected theorem star_inv' [DivisionSemiring α] [StarRing α] (s : Set α) : s⁻¹⋆ = s⋆⁻¹ 
Arguments: {α : Type u_1} [DivisionSemiring α] [StarRing α] (s : Set α)
Goal: star s⁻¹ = (star s)⁻¹
-- StarMemClass.star_coe_eq
@[simp]
lemma StarMemClass.star_coe_eq {S α : Type*} [InvolutiveStar α] [SetLike S α]
    [StarMemClass S α] (s : S) : star (s : Set α) = s 
Arguments: {S : Type u_1} {α : Type u_2} [InvolutiveStar α] [SetLike S α] [StarMemClass S α] (s : S)
Goal: star ↑s = ↑s
-- FreeMonoid.star_of
@[simp]
theorem star_of (x : α) : star (of x) = of x 
Arguments: {α : Type u_1} (x : α)
Goal: star (FreeMonoid.of x) = FreeMonoid.of x
-- FreeMonoid.star_one
@[simp]
theorem star_one : star (1 : FreeMonoid α) = 1 
Arguments: {α : Type u_1}
Goal: star 1 = 1
-- FreeAlgebra.star_ι
@[simp]
theorem star_ι (x : X) : star (ι R x) = ι R x 
Arguments: {R : Type u_1} [CommSemiring R] {X : Type u_2} (x : X)
Goal: star (FreeAlgebra.ι R x) = FreeAlgebra.ι R x
-- FreeAlgebra.star_algebraMap
@[simp]
theorem star_algebraMap (r : R) : star (algebraMap R (FreeAlgebra R X) r) = algebraMap R _ r 
Arguments: {R : Type u_1} [CommSemiring R] {X : Type u_2} (r : R)
Goal: star ((algebraMap R (FreeAlgebra R X)) r) = (algebraMap R (FreeAlgebra R X)) r
-- isPrimePow_def
theorem isPrimePow_def : IsPrimePow n ↔ ∃ (p : R) (k : ℕ), Prime p ∧ 0 < k ∧ p ^ k = n 
Arguments: {R : Type u_1} [CommMonoidWithZero R] (n : R)
Goal: IsPrimePow n ↔ ∃ p k, Prime p ∧ 0 < k ∧ p ^ k = n
-- isPrimePow_iff_pow_succ
theorem isPrimePow_iff_pow_succ : IsPrimePow n ↔ ∃ (p : R) (k : ℕ), Prime p ∧ p ^ (k + 1) = n 
Arguments: {R : Type u_1} [CommMonoidWithZero R] (n : R)
Goal: IsPrimePow n ↔ ∃ p k, Prime p ∧ p ^ (k + 1) = n
-- not_isPrimePow_zero
theorem not_isPrimePow_zero [NoZeroDivisors R] : ¬IsPrimePow (0 : R) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] [NoZeroDivisors R]
Goal: ¬IsPrimePow 0
-- IsPrimePow.not_unit
theorem IsPrimePow.not_unit {n : R} (h : IsPrimePow n) : ¬IsUnit n 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : R} (h : IsPrimePow n)
Goal: ¬IsUnit n
-- IsUnit.not_isPrimePow
theorem IsUnit.not_isPrimePow {n : R} (h : IsUnit n) : ¬IsPrimePow n 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : R} (h : IsUnit n)
Goal: ¬IsPrimePow n
-- not_isPrimePow_one
theorem not_isPrimePow_one : ¬IsPrimePow (1 : R) 
Arguments: {R : Type u_1} [CommMonoidWithZero R]
Goal: ¬IsPrimePow 1
-- Prime.isPrimePow
theorem Prime.isPrimePow {p : R} (hp : Prime p) : IsPrimePow p 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {p : R} (hp : Prime p)
Goal: IsPrimePow p
-- IsPrimePow.pow
theorem IsPrimePow.pow {n : R} (hn : IsPrimePow n) {k : ℕ} (hk : k ≠ 0) : IsPrimePow (n ^ k) 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : R} (hn : IsPrimePow n) {k : ℕ} (hk : k ≠ 0)
Goal: IsPrimePow (n ^ k)
-- IsPrimePow.ne_zero
theorem IsPrimePow.ne_zero [NoZeroDivisors R] {n : R} (h : IsPrimePow n) : n ≠ 0 
Arguments: {R : Type u_1} [CommMonoidWithZero R] [NoZeroDivisors R] {n : R} (h : IsPrimePow n)
Goal: n ≠ 0
-- IsPrimePow.ne_one
theorem IsPrimePow.ne_one {n : R} (h : IsPrimePow n) : n ≠ 1 
Arguments: {R : Type u_1} [CommMonoidWithZero R] {n : R} (h : IsPrimePow n)
Goal: n ≠ 1
-- isPrimePow_nat_iff
theorem isPrimePow_nat_iff (n : ℕ) : IsPrimePow n ↔ ∃ p k : ℕ, Nat.Prime p ∧ 0 < k ∧ p ^ k = n 
Arguments: (n : ℕ)
Goal: IsPrimePow n ↔ ∃ p k, Nat.Prime p ∧ 0 < k ∧ p ^ k = n
-- Nat.Prime.isPrimePow
theorem Nat.Prime.isPrimePow {p : ℕ} (hp : p.Prime) : IsPrimePow p 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: IsPrimePow p
-- isPrimePow_nat_iff_bounded
theorem isPrimePow_nat_iff_bounded (n : ℕ) :
    IsPrimePow n ↔ ∃ p : ℕ, p ≤ n ∧ ∃ k : ℕ, k ≤ n ∧ p.Prime ∧ 0 < k ∧ p ^ k = n 
Arguments: (n : ℕ)
Goal: IsPrimePow n ↔ ∃ p ≤ n, ∃ k ≤ n, Nat.Prime p ∧ 0 < k ∧ p ^ k = n
-- IsPrimePow.dvd
theorem IsPrimePow.dvd {n m : ℕ} (hn : IsPrimePow n) (hm : m ∣ n) (hm₁ : m ≠ 1) : IsPrimePow m 
Arguments: {n m : ℕ} (hn : IsPrimePow n) (hm : m ∣ n) (hm₁ : m ≠ 1)
Goal: IsPrimePow m
-- Nat.disjoint_divisors_filter_isPrimePow
theorem Nat.disjoint_divisors_filter_isPrimePow {a b : ℕ} (hab : a.Coprime b) :
    Disjoint (a.divisors.filter IsPrimePow) (b.divisors.filter IsPrimePow) 
Arguments: {a b : ℕ} (hab : a.Coprime b)
Goal: Disjoint (Finset.filter IsPrimePow a.divisors) (Finset.filter IsPrimePow b.divisors)
-- IsPrimePow.two_le
theorem IsPrimePow.two_le : ∀ {n : ℕ}, IsPrimePow n → 2 ≤ n
  
Arguments: {n : ℕ}
Goal: IsPrimePow n → 2 ≤ n
-- IsPrimePow.pos
theorem IsPrimePow.pos {n : ℕ} (hn : IsPrimePow n) : 0 < n 
Arguments: {n : ℕ} (hn : IsPrimePow n)
Goal: 0 < n
-- IsPrimePow.one_lt
theorem IsPrimePow.one_lt {n : ℕ} (h : IsPrimePow n) : 1 < n 
Arguments: {n : ℕ} (h : IsPrimePow n)
Goal: 1 < n
-- CharZero.cast_injective
class CharZero (R) [AddMonoidWithOne R] : Prop where
    cast_injective : Function.Injective (Nat.cast : ℕ → R)
Arguments: {R : Type u_1} [AddMonoidWithOne R] [self : CharZero R]
Goal: Function.Injective Nat.cast
-- charZero_of_inj_zero
theorem charZero_of_inj_zero [AddGroupWithOne R] (H : ∀ n : ℕ, (n : R) = 0 → n = 0) :
    CharZero R 
Arguments: {R : Type u_1} [AddGroupWithOne R] (H : ∀ (n : ℕ), ↑n = 0 → n = 0)
Goal: CharZero R
-- Nat.cast_injective
theorem cast_injective : Function.Injective (Nat.cast : ℕ → R) 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R]
Goal: Function.Injective Nat.cast
-- Nat.cast_inj
@[simp, norm_cast]
theorem cast_inj {m n : ℕ} : (m : R) = n ↔ m = n 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R] {m n : ℕ}
Goal: ↑m = ↑n ↔ m = n
-- Nat.cast_eq_zero
@[simp, norm_cast]
theorem cast_eq_zero {n : ℕ} : (n : R) = 0 ↔ n = 0 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R] {n : ℕ}
Goal: ↑n = 0 ↔ n = 0
-- Nat.cast_ne_zero
@[norm_cast]
theorem cast_ne_zero {n : ℕ} : (n : R) ≠ 0 ↔ n ≠ 0 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R] {n : ℕ}
Goal: ↑n ≠ 0 ↔ n ≠ 0
-- Nat.cast_add_one_ne_zero
theorem cast_add_one_ne_zero (n : ℕ) : (n + 1 : R) ≠ 0 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R] (n : ℕ)
Goal: ↑n + 1 ≠ 0
-- Nat.cast_eq_one
@[simp, norm_cast]
theorem cast_eq_one {n : ℕ} : (n : R) = 1 ↔ n = 1 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R] {n : ℕ}
Goal: ↑n = 1 ↔ n = 1
-- Nat.cast_ne_one
@[norm_cast]
theorem cast_ne_one {n : ℕ} : (n : R) ≠ 1 ↔ n ≠ 1 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R] {n : ℕ}
Goal: ↑n ≠ 1 ↔ n ≠ 1
-- OfNat.ofNat_ne_zero
@[simp] lemma ofNat_ne_zero (n : ℕ) [n.AtLeastTwo] : (no_index (ofNat n) : R) ≠ 0 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R] (n : ℕ) [n.AtLeastTwo]
Goal: OfNat.ofNat n ≠ 0
-- OfNat.zero_ne_ofNat
@[simp] lemma zero_ne_ofNat (n : ℕ) [n.AtLeastTwo] : 0 ≠ (no_index (ofNat n) : R) 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R] (n : ℕ) [n.AtLeastTwo]
Goal: 0 ≠ OfNat.ofNat n
-- OfNat.ofNat_ne_one
@[simp] lemma ofNat_ne_one (n : ℕ) [n.AtLeastTwo] : (no_index (ofNat n) : R) ≠ 1 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R] (n : ℕ) [n.AtLeastTwo]
Goal: OfNat.ofNat n ≠ 1
-- OfNat.one_ne_ofNat
@[simp] lemma one_ne_ofNat (n : ℕ) [n.AtLeastTwo] : (1 : R) ≠ no_index (ofNat n) 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R] (n : ℕ) [n.AtLeastTwo]
Goal: 1 ≠ OfNat.ofNat n
-- OfNat.ofNat_eq_ofNat
@[simp] lemma ofNat_eq_ofNat {m n : ℕ} [m.AtLeastTwo] [n.AtLeastTwo] :
    (no_index (ofNat m) : R) = no_index (ofNat n) ↔ (ofNat m : ℕ) = ofNat n 
Arguments: {R : Type u_1} [AddMonoidWithOne R] [CharZero R] {m n : ℕ} [m.AtLeastTwo] [n.AtLeastTwo]
Goal: OfNat.ofNat m = OfNat.ofNat n ↔ OfNat.ofNat m = OfNat.ofNat n
-- MvPolynomial.pUnitAlgEquiv_apply
@[simps]
def pUnitAlgEquiv : MvPolynomial PUnit R ≃ₐ[R] R[X] 
Arguments: (R : Type u) [CommSemiring R] (p : MvPolynomial PUnit.{u_2 + 1} R)
Goal: (MvPolynomial.pUnitAlgEquiv R) p = MvPolynomial.eval₂ Polynomial.C (fun x => Polynomial.X) p
-- MvPolynomial.pUnitAlgEquiv_symm_apply
@[simps]
def pUnitAlgEquiv : MvPolynomial PUnit R ≃ₐ[R] R[X] 
Arguments: (R : Type u) [CommSemiring R] (p : R[X])
Goal: (MvPolynomial.pUnitAlgEquiv R).symm p = Polynomial.eval₂ MvPolynomial.C (MvPolynomial.X PUnit.unit) p
-- MvPolynomial.mapEquiv_apply
@[simps apply]
def mapEquiv [CommSemiring S₁] [CommSemiring S₂] (e : S₁ ≃+* S₂) :
    MvPolynomial σ S₁ ≃+* MvPolynomial σ S₂ 
Arguments: {S₁ : Type v} {S₂ : Type w} (σ : Type u_1) [CommSemiring S₁] [CommSemiring S₂] (e : S₁ ≃+* S₂) (a : MvPolynomial σ S₁)
Goal: (MvPolynomial.mapEquiv σ e) a = (MvPolynomial.map ↑e) a
-- MvPolynomial.mapEquiv_refl
@[simp]
theorem mapEquiv_refl : mapEquiv σ (RingEquiv.refl R) = RingEquiv.refl _ 
Arguments: {R : Type u} (σ : Type u_1) [CommSemiring R]
Goal: MvPolynomial.mapEquiv σ (RingEquiv.refl R) = RingEquiv.refl (MvPolynomial σ R)
-- MvPolynomial.mapEquiv_symm
@[simp]
theorem mapEquiv_symm [CommSemiring S₁] [CommSemiring S₂] (e : S₁ ≃+* S₂) :
    (mapEquiv σ e).symm = mapEquiv σ e.symm 
Arguments: {S₁ : Type v} {S₂ : Type w} (σ : Type u_1) [CommSemiring S₁] [CommSemiring S₂] (e : S₁ ≃+* S₂)
Goal: (MvPolynomial.mapEquiv σ e).symm = MvPolynomial.mapEquiv σ e.symm
-- MvPolynomial.mapEquiv_trans
@[simp]
theorem mapEquiv_trans [CommSemiring S₁] [CommSemiring S₂] [CommSemiring S₃] (e : S₁ ≃+* S₂)
    (f : S₂ ≃+* S₃) : (mapEquiv σ e).trans (mapEquiv σ f) = mapEquiv σ (e.trans f) 
Arguments: {S₁ : Type v} {S₂ : Type w} {S₃ : Type x} (σ : Type u_1) [CommSemiring S₁] [CommSemiring S₂] [CommSemiring S₃] (e : S₁ ≃+* S₂) (f : S₂ ≃+* S₃)
Goal: (MvPolynomial.mapEquiv σ e).trans (MvPolynomial.mapEquiv σ f) = MvPolynomial.mapEquiv σ (e.trans f)
-- MvPolynomial.mapAlgEquiv_apply
@[simps apply]
def mapAlgEquiv (e : A₁ ≃ₐ[R] A₂) : MvPolynomial σ A₁ ≃ₐ[R] MvPolynomial σ A₂ 
Arguments: {R : Type u} (σ : Type u_1) [CommSemiring R] {A₁ : Type u_2} {A₂ : Type u_3} [CommSemiring A₁] [CommSemiring A₂] [Algebra R A₁] [Algebra R A₂] (e : A₁ ≃ₐ[R] A₂) (a : MvPolynomial σ A₁)
Goal: (MvPolynomial.mapAlgEquiv σ e) a = (MvPolynomial.map ↑e) a
-- MvPolynomial.mapAlgEquiv_refl
@[simp]
theorem mapAlgEquiv_refl : mapAlgEquiv σ (AlgEquiv.refl : A₁ ≃ₐ[R] A₁) = AlgEquiv.refl 
Arguments: {R : Type u} (σ : Type u_1) [CommSemiring R] {A₁ : Type u_2} [CommSemiring A₁] [Algebra R A₁]
Goal: MvPolynomial.mapAlgEquiv σ AlgEquiv.refl = AlgEquiv.refl
-- MvPolynomial.mapAlgEquiv_symm
@[simp]
theorem mapAlgEquiv_symm (e : A₁ ≃ₐ[R] A₂) : (mapAlgEquiv σ e).symm = mapAlgEquiv σ e.symm 
Arguments: {R : Type u} (σ : Type u_1) [CommSemiring R] {A₁ : Type u_2} {A₂ : Type u_3} [CommSemiring A₁] [CommSemiring A₂] [Algebra R A₁] [Algebra R A₂] (e : A₁ ≃ₐ[R] A₂)
Goal: (MvPolynomial.mapAlgEquiv σ e).symm = MvPolynomial.mapAlgEquiv σ e.symm
-- MvPolynomial.mapAlgEquiv_trans
@[simp]
theorem mapAlgEquiv_trans (e : A₁ ≃ₐ[R] A₂) (f : A₂ ≃ₐ[R] A₃) :
    (mapAlgEquiv σ e).trans (mapAlgEquiv σ f) = mapAlgEquiv σ (e.trans f) 
Arguments: {R : Type u} (σ : Type u_1) [CommSemiring R] {A₁ : Type u_2} {A₂ : Type u_3} {A₃ : Type u_4} [CommSemiring A₁] [CommSemiring A₂] [CommSemiring A₃] [Algebra R A₁] [Algebra R A₂] [Algebra R A₃] (e : A₁ ≃ₐ[R] A₂) (f : A₂ ≃ₐ[R] A₃)
Goal: (MvPolynomial.mapAlgEquiv σ e).trans (MvPolynomial.mapAlgEquiv σ f) = MvPolynomial.mapAlgEquiv σ (e.trans f)
-- MvPolynomial.sumToIter_C
@[simp]
theorem sumToIter_C (a : R) : sumToIter R S₁ S₂ (C a) = C (C a) 
Arguments: (R : Type u) (S₁ : Type v) (S₂ : Type w) [CommSemiring R] (a : R)
Goal: (MvPolynomial.sumToIter R S₁ S₂) (MvPolynomial.C a) = MvPolynomial.C (MvPolynomial.C a)
-- MvPolynomial.sumToIter_Xl
@[simp]
theorem sumToIter_Xl (b : S₁) : sumToIter R S₁ S₂ (X (Sum.inl b)) = X b 
Arguments: (R : Type u) (S₁ : Type v) (S₂ : Type w) [CommSemiring R] (b : S₁)
Goal: (MvPolynomial.sumToIter R S₁ S₂) (MvPolynomial.X (Sum.inl b)) = MvPolynomial.X b
-- MvPolynomial.sumToIter_Xr
@[simp]
theorem sumToIter_Xr (c : S₂) : sumToIter R S₁ S₂ (X (Sum.inr c)) = C (X c) 
Arguments: (R : Type u) (S₁ : Type v) (S₂ : Type w) [CommSemiring R] (c : S₂)
Goal: (MvPolynomial.sumToIter R S₁ S₂) (MvPolynomial.X (Sum.inr c)) = MvPolynomial.C (MvPolynomial.X c)
-- MvPolynomial.iterToSum_C_C
@[simp]
theorem iterToSum_C_C (a : R) : iterToSum R S₁ S₂ (C (C a)) = C a 
Arguments: (R : Type u) (S₁ : Type v) (S₂ : Type w) [CommSemiring R] (a : R)
Goal: (MvPolynomial.iterToSum R S₁ S₂) (MvPolynomial.C (MvPolynomial.C a)) = MvPolynomial.C a
-- MvPolynomial.iterToSum_X
@[simp]
theorem iterToSum_X (b : S₁) : iterToSum R S₁ S₂ (X b) = X (Sum.inl b) 
Arguments: (R : Type u) (S₁ : Type v) (S₂ : Type w) [CommSemiring R] (b : S₁)
Goal: (MvPolynomial.iterToSum R S₁ S₂) (MvPolynomial.X b) = MvPolynomial.X (Sum.inl b)
-- MvPolynomial.iterToSum_C_X
@[simp]
theorem iterToSum_C_X (c : S₂) : iterToSum R S₁ S₂ (C (X c)) = X (Sum.inr c) 
Arguments: (R : Type u) (S₁ : Type v) (S₂ : Type w) [CommSemiring R] (c : S₂)
Goal: (MvPolynomial.iterToSum R S₁ S₂) (MvPolynomial.C (MvPolynomial.X c)) = MvPolynomial.X (Sum.inr c)
-- MvPolynomial.isEmptyAlgEquiv_apply
@[simps!]
def isEmptyAlgEquiv [he : IsEmpty σ] : MvPolynomial σ R ≃ₐ[R] R 
Arguments: (R : Type u) (σ : Type u_1) [CommSemiring R] [he : IsEmpty σ] (a : MvPolynomial σ R)
Goal: (MvPolynomial.isEmptyAlgEquiv R σ) a = (MvPolynomial.aeval fun a => he.elim a) a
-- MvPolynomial.isEmptyAlgEquiv_symm_apply_toFun
@[simps!]
def isEmptyAlgEquiv [he : IsEmpty σ] : MvPolynomial σ R ≃ₐ[R] R 
Arguments: (R : Type u) (σ : Type u_1) [CommSemiring R] [he : IsEmpty σ] (a : R) (j : σ →₀ ℕ)
Goal: ((MvPolynomial.isEmptyAlgEquiv R σ).symm a) j = Pi.single 0 a j
-- MvPolynomial.isEmptyAlgEquiv_symm_apply_support
@[simps!]
def isEmptyAlgEquiv [he : IsEmpty σ] : MvPolynomial σ R ≃ₐ[R] R 
Arguments: (R : Type u) (σ : Type u_1) [CommSemiring R] [he : IsEmpty σ] (a : R)
Goal: ((MvPolynomial.isEmptyAlgEquiv R σ).symm a).support = if a = 0 then ∅ else {0}
-- MvPolynomial.isEmptyRingEquiv_symm_apply_support
@[simps!]
def isEmptyRingEquiv [IsEmpty σ] : MvPolynomial σ R ≃+* R 
Arguments: (R : Type u) (σ : Type u_1) [CommSemiring R] [IsEmpty σ] (a : R)
Goal: ((MvPolynomial.isEmptyRingEquiv R σ).symm a).support = if a = 0 then ∅ else {0}
-- MvPolynomial.isEmptyRingEquiv_apply
@[simps!]
def isEmptyRingEquiv [IsEmpty σ] : MvPolynomial σ R ≃+* R 
Arguments: (R : Type u) (σ : Type u_1) [CommSemiring R] [IsEmpty σ] (a : MvPolynomial σ R)
Goal: (MvPolynomial.isEmptyRingEquiv R σ) a = (MvPolynomial.aeval fun a => inst✝.elim a) a
-- MvPolynomial.isEmptyRingEquiv_symm_apply_toFun
@[simps!]
def isEmptyRingEquiv [IsEmpty σ] : MvPolynomial σ R ≃+* R 
Arguments: (R : Type u) (σ : Type u_1) [CommSemiring R] [IsEmpty σ] (a : R) (j : σ →₀ ℕ)
Goal: ((MvPolynomial.isEmptyRingEquiv R σ).symm a) j = Pi.single 0 a j
-- MvPolynomial.mvPolynomialEquivMvPolynomial_apply
@[simps]
def mvPolynomialEquivMvPolynomial [CommSemiring S₃] (f : MvPolynomial S₁ R →+* MvPolynomial S₂ S₃)
    (g : MvPolynomial S₂ S₃ →+* MvPolynomial S₁ R) (hfgC : (f.comp g).comp C = C)
    (hfgX : ∀ n, f (g (X n)) = X n) (hgfC : (g.comp f).comp C = C) (hgfX : ∀ n, g (f (X n)) = X n) :
    MvPolynomial S₁ R ≃+* MvPolynomial S₂ S₃ 
Arguments: (R : Type u) (S₁ : Type v) (S₂ : Type w) (S₃ : Type x) [CommSemiring R] [CommSemiring S₃] (f : MvPolynomial S₁ R →+* MvPolynomial S₂ S₃) (g : MvPolynomial S₂ S₃ →+* MvPolynomial S₁ R) (hfgC : (f.comp g).comp MvPolynomial.C = MvPolynomial.C) (hfgX : ∀ (n : S₂), f (g (MvPolynomial.X n)) = MvPolynomial.X n) (hgfC : (g.comp f).comp MvPolynomial.C = MvPolynomial.C) (hgfX : ∀ (n : S₁), g (f (MvPolynomial.X n)) = MvPolynomial.X n) (a : MvPolynomial S₁ R)
Goal: (MvPolynomial.mvPolynomialEquivMvPolynomial R S₁ S₂ S₃ f g hfgC hfgX hgfC hgfX) a = f a
-- MvPolynomial.mvPolynomialEquivMvPolynomial_symm_apply
@[simps]
def mvPolynomialEquivMvPolynomial [CommSemiring S₃] (f : MvPolynomial S₁ R →+* MvPolynomial S₂ S₃)
    (g : MvPolynomial S₂ S₃ →+* MvPolynomial S₁ R) (hfgC : (f.comp g).comp C = C)
    (hfgX : ∀ n, f (g (X n)) = X n) (hgfC : (g.comp f).comp C = C) (hgfX : ∀ n, g (f (X n)) = X n) :
    MvPolynomial S₁ R ≃+* MvPolynomial S₂ S₃ 
Arguments: (R : Type u) (S₁ : Type v) (S₂ : Type w) (S₃ : Type x) [CommSemiring R] [CommSemiring S₃] (f : MvPolynomial S₁ R →+* MvPolynomial S₂ S₃) (g : MvPolynomial S₂ S₃ →+* MvPolynomial S₁ R) (hfgC : (f.comp g).comp MvPolynomial.C = MvPolynomial.C) (hfgX : ∀ (n : S₂), f (g (MvPolynomial.X n)) = MvPolynomial.X n) (hgfC : (g.comp f).comp MvPolynomial.C = MvPolynomial.C) (hgfX : ∀ (n : S₁), g (f (MvPolynomial.X n)) = MvPolynomial.X n) (a : MvPolynomial S₂ S₃)
Goal: (MvPolynomial.mvPolynomialEquivMvPolynomial R S₁ S₂ S₃ f g hfgC hfgX hgfC hgfX).symm a = g a
-- MvPolynomial.sumAlgEquiv_symm_apply
@[simps!]
def sumAlgEquiv : MvPolynomial (S₁ ⊕ S₂) R ≃ₐ[R] MvPolynomial S₁ (MvPolynomial S₂ R) 
Arguments: (R : Type u) (S₁ : Type v) (S₂ : Type w) [CommSemiring R] (a : MvPolynomial S₁ (MvPolynomial S₂ R))
Goal: (MvPolynomial.sumAlgEquiv R S₁ S₂).symm a = (MvPolynomial.iterToSum R S₁ S₂) a
-- MvPolynomial.sumAlgEquiv_apply
@[simps!]
def sumAlgEquiv : MvPolynomial (S₁ ⊕ S₂) R ≃ₐ[R] MvPolynomial S₁ (MvPolynomial S₂ R) 
Arguments: (R : Type u) (S₁ : Type v) (S₂ : Type w) [CommSemiring R] (a : MvPolynomial (S₁ ⊕ S₂) R)
Goal: (MvPolynomial.sumAlgEquiv R S₁ S₂) a = (MvPolynomial.sumToIter R S₁ S₂) a
-- MvPolynomial.optionEquivLeft_symm_apply
@[simps!]
def optionEquivLeft : MvPolynomial (Option S₁) R ≃ₐ[R] Polynomial (MvPolynomial S₁ R) 
Arguments: (R : Type u) (S₁ : Type v) [CommSemiring R] (a : (MvPolynomial S₁ R)[X])
Goal: (MvPolynomial.optionEquivLeft R S₁).symm a = (Polynomial.aevalTower (MvPolynomial.rename some) (MvPolynomial.X none)) a
-- MvPolynomial.optionEquivLeft_apply
@[simps!]
def optionEquivLeft : MvPolynomial (Option S₁) R ≃ₐ[R] Polynomial (MvPolynomial S₁ R) 
Arguments: (R : Type u) (S₁ : Type v) [CommSemiring R] (a : MvPolynomial (Option S₁) R)
Goal: (MvPolynomial.optionEquivLeft R S₁) a =
  (MvPolynomial.aeval fun o => o.elim Polynomial.X fun s => Polynomial.C (MvPolynomial.X s)) a