ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- FreeMonoid.map_comp
@[to_additive]
theorem map_comp (g : β → γ) (f : α → β) : map (g ∘ f) = (map g).comp (map f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β)
Goal: FreeMonoid.map (g ∘ f) = (FreeMonoid.map g).comp (FreeMonoid.map f)
-- FreeAddMonoid.map_comp
@[to_additive]
theorem map_comp (g : β → γ) (f : α → β) : map (g ∘ f) = (map g).comp (map f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β)
Goal: FreeAddMonoid.map (g ∘ f) = (FreeAddMonoid.map g).comp (FreeAddMonoid.map f)
-- FreeMonoid.map_id
@[to_additive (attr := simp)]
theorem map_id : map (@id α) = MonoidHom.id (FreeMonoid α) 
Arguments: {α : Type u_1}
Goal: FreeMonoid.map id = MonoidHom.id (FreeMonoid α)
-- FreeAddMonoid.map_id
@[to_additive (attr := simp)]
theorem map_id : map (@id α) = MonoidHom.id (FreeMonoid α) 
Arguments: {α : Type u_1}
Goal: FreeAddMonoid.map id = AddMonoidHom.id (FreeAddMonoid α)
-- FreeAddMonoid.countP_of
theorem countP_of (x : α) : countP p (of x) = if p x = true then 1 else 0 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (x : α)
Goal: (FreeAddMonoid.countP p) (FreeAddMonoid.of x) = if p x = (true = true) then 1 else 0
-- FreeAddMonoid.countP_apply
theorem countP_apply (l : FreeAddMonoid α) : countP p l = List.countP p l 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (l : FreeAddMonoid α)
Goal: (FreeAddMonoid.countP p) l = List.countP (fun b => decide (p b)) l
-- FreeAddMonoid.count_of
theorem count_of [DecidableEq α] (x y : α) : count x (of y) = (Pi.single x 1 : α → ℕ) y 
Arguments: {α : Type u_1} [DecidableEq α] (x y : α)
Goal: (FreeAddMonoid.count x) (FreeAddMonoid.of y) = Pi.single x 1 y
-- FreeAddMonoid.count_apply
theorem count_apply [DecidableEq α] (x : α) (l : FreeAddMonoid α) : count x l = List.count x l 
Arguments: {α : Type u_1} [DecidableEq α] (x : α) (l : FreeAddMonoid α)
Goal: (FreeAddMonoid.count x) l = List.count x l
-- FreeMonoid.countP_of'
theorem countP_of' (x : α) :
    countP p (of x) = if p x then Multiplicative.ofAdd 1 else Multiplicative.ofAdd 0 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (x : α)
Goal: (FreeMonoid.countP p) (FreeMonoid.of x) = if p x then Multiplicative.ofAdd 1 else Multiplicative.ofAdd 0
-- FreeMonoid.countP_of
theorem countP_of (x : α) : countP p (of x) = if p x then Multiplicative.ofAdd 1 else 1 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (x : α)
Goal: (FreeMonoid.countP p) (FreeMonoid.of x) = if p x then Multiplicative.ofAdd 1 else 1
-- FreeMonoid.countP_apply
theorem countP_apply (l : FreeAddMonoid α) : countP p l = Multiplicative.ofAdd (List.countP p l) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (l : FreeAddMonoid α)
Goal: (FreeMonoid.countP p) l = Multiplicative.ofAdd (List.countP (fun b => decide (p b)) l)
-- FreeMonoid.count_apply
theorem count_apply [DecidableEq α] (x : α) (l : FreeAddMonoid α) :
    count x l = Multiplicative.ofAdd (List.count x l) 
Arguments: {α : Type u_1} [DecidableEq α] (x : α) (l : FreeAddMonoid α)
Goal: (FreeMonoid.count x) l = Multiplicative.ofAdd (List.count x l)
-- FreeMonoid.count_of
theorem count_of [DecidableEq α] (x y : α) :
    count x (of y) = @Pi.mulSingle α (fun _ => Multiplicative ℕ) _ _ x (Multiplicative.ofAdd 1) y 
Arguments: {α : Type u_1} [DecidableEq α] (x y : α)
Goal: (FreeMonoid.count x) (FreeMonoid.of y) = Pi.mulSingle x (Multiplicative.ofAdd 1) y
-- star_prod
@[simp]
theorem star_prod [CommMonoid R] [StarMul R] {α : Type*} (s : Finset α) (f : α → R) :
    star (∏ x ∈ s, f x) = ∏ x ∈ s, star (f x) 
Arguments: {R : Type u_1} [CommMonoid R] [StarMul R] {α : Type u_2} (s : Finset α) (f : α → R)
Goal: star (∏ x ∈ s, f x) = ∏ x ∈ s, star (f x)
-- star_sum
@[simp]
theorem star_sum [AddCommMonoid R] [StarAddMonoid R] {α : Type*} (s : Finset α) (f : α → R) :
    star (∑ x ∈ s, f x) = ∑ x ∈ s, star (f x) 
Arguments: {R : Type u_1} [AddCommMonoid R] [StarAddMonoid R] {α : Type u_2} (s : Finset α) (f : α → R)
Goal: star (∑ x ∈ s, f x) = ∑ x ∈ s, star (f x)
-- SubStarSemigroup.star_mem'
structure SubStarSemigroup (M : Type v) [Mul M] [Star M] extends Subsemigroup M : Type v where
    star_mem' : ∀ {a : M} (_ha : a ∈ carrier), star a ∈ carrier
Arguments: {M : Type v} [Mul M] [Star M] (self : SubStarSemigroup M) {a : M} (_ha : a ∈ self.carrier)
Goal: star a ∈ self.carrier
-- NonUnitalStarSubsemiring.star_mem'
structure NonUnitalStarSubsemiring (R : Type v) [NonUnitalNonAssocSemiring R] [Star R]
    extends NonUnitalSubsemiring R : Type v where
    star_mem' : ∀ {a : R} (_ha : a ∈ carrier), star a ∈ carrier
Arguments: {R : Type v} [NonUnitalNonAssocSemiring R] [Star R] (self : NonUnitalStarSubsemiring R) {a : R} (_ha : a ∈ self.carrier)
Goal: star a ∈ self.carrier
-- NonUnitalStarSubsemiring.mem_carrier
theorem mem_carrier {s : NonUnitalStarSubsemiring R} {x : R} : x ∈ s.carrier ↔ x ∈ s 
Arguments: {R : Type v} [NonUnitalNonAssocSemiring R] [StarRing R] {s : NonUnitalStarSubsemiring R} {x : R}
Goal: x ∈ s.carrier ↔ x ∈ s
-- NonUnitalStarSubsemiring.coe_copy
@[simp]
theorem coe_copy (S : NonUnitalStarSubsemiring R) (s : Set R) (hs : s = ↑S) :
    (S.copy s hs : Set R) = s 
Arguments: {R : Type v} [NonUnitalNonAssocSemiring R] [StarRing R] (S : NonUnitalStarSubsemiring R) (s : Set R) (hs : s = ↑S)
Goal: ↑(S.copy s hs) = s
-- NonUnitalStarSubsemiring.copy_eq
theorem copy_eq (S : NonUnitalStarSubsemiring R) (s : Set R) (hs : s = ↑S) : S.copy s hs = S 
Arguments: {R : Type v} [NonUnitalNonAssocSemiring R] [StarRing R] (S : NonUnitalStarSubsemiring R) (s : Set R) (hs : s = ↑S)
Goal: S.copy s hs = S
-- MvPolynomial.vars_def
theorem vars_def [DecidableEq σ] (p : MvPolynomial σ R) : p.vars = p.degrees.toFinset 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] [DecidableEq σ] (p : MvPolynomial σ R)
Goal: p.vars = p.degrees.toFinset
-- MvPolynomial.vars_0
@[simp]
theorem vars_0 : (0 : MvPolynomial σ R).vars = ∅ 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R]
Goal: MvPolynomial.vars 0 = ∅
-- MvPolynomial.vars_monomial
@[simp]
theorem vars_monomial (h : r ≠ 0) : (monomial s r).vars = s.support 
Arguments: {R : Type u} {σ : Type u_1} {r : R} {s : σ →₀ ℕ} [CommSemiring R] (h : r ≠ 0)
Goal: ((MvPolynomial.monomial s) r).vars = s.support
-- MvPolynomial.vars_C
@[simp]
theorem vars_C : (C r : MvPolynomial σ R).vars = ∅ 
Arguments: {R : Type u} {σ : Type u_1} {r : R} [CommSemiring R]
Goal: (MvPolynomial.C r).vars = ∅
-- MvPolynomial.vars_X
@[simp]
theorem vars_X [Nontrivial R] : (X n : MvPolynomial σ R).vars = {n} 
Arguments: {R : Type u} {σ : Type u_1} {n : σ} [CommSemiring R] [Nontrivial R]
Goal: (MvPolynomial.X n).vars = {n}
-- MvPolynomial.mem_vars
theorem mem_vars (i : σ) : i ∈ p.vars ↔ ∃ d ∈ p.support, i ∈ d.support 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {p : MvPolynomial σ R} (i : σ)
Goal: i ∈ p.vars ↔ ∃ d ∈ p.support, i ∈ d.support
-- MvPolynomial.mem_support_not_mem_vars_zero
theorem mem_support_not_mem_vars_zero {f : MvPolynomial σ R} {x : σ →₀ ℕ} (H : x ∈ f.support)
    {v : σ} (h : v ∉ vars f) : x v = 0 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {f : MvPolynomial σ R} {x : σ →₀ ℕ} (H : x ∈ f.support) {v : σ} (h : v ∉ f.vars)
Goal: x v = 0
-- MvPolynomial.vars_add_subset
theorem vars_add_subset [DecidableEq σ] (p q : MvPolynomial σ R) :
    (p + q).vars ⊆ p.vars ∪ q.vars 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] [DecidableEq σ] (p q : MvPolynomial σ R)
Goal: (p + q).vars ⊆ p.vars ∪ q.vars
-- MvPolynomial.vars_add_of_disjoint
theorem vars_add_of_disjoint [DecidableEq σ] (h : Disjoint p.vars q.vars) :
    (p + q).vars = p.vars ∪ q.vars 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {p q : MvPolynomial σ R} [DecidableEq σ] (h : Disjoint p.vars q.vars)
Goal: (p + q).vars = p.vars ∪ q.vars
-- MvPolynomial.vars_mul
theorem vars_mul [DecidableEq σ] (φ ψ : MvPolynomial σ R) : (φ * ψ).vars ⊆ φ.vars ∪ ψ.vars 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] [DecidableEq σ] (φ ψ : MvPolynomial σ R)
Goal: (φ * ψ).vars ⊆ φ.vars ∪ ψ.vars
-- MvPolynomial.vars_one
@[simp]
theorem vars_one : (1 : MvPolynomial σ R).vars = ∅ 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R]
Goal: MvPolynomial.vars 1 = ∅
-- MvPolynomial.vars_pow
theorem vars_pow (φ : MvPolynomial σ R) (n : ℕ) : (φ ^ n).vars ⊆ φ.vars 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (φ : MvPolynomial σ R) (n : ℕ)
Goal: (φ ^ n).vars ⊆ φ.vars
-- MvPolynomial.vars_prod
theorem vars_prod {ι : Type*} [DecidableEq σ] {s : Finset ι} (f : ι → MvPolynomial σ R) :
    (∏ i ∈ s, f i).vars ⊆ s.biUnion fun i => (f i).vars 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {ι : Type u_3} [DecidableEq σ] {s : Finset ι} (f : ι → MvPolynomial σ R)
Goal: (∏ i ∈ s, f i).vars ⊆ s.biUnion fun i => (f i).vars
-- MvPolynomial.vars_C_mul
theorem vars_C_mul (a : A) (ha : a ≠ 0) (φ : MvPolynomial σ A) :
    (C a * φ : MvPolynomial σ A).vars = φ.vars 
Arguments: {σ : Type u_1} {A : Type u_3} [CommRing A] [IsDomain A] (a : A) (ha : a ≠ 0) (φ : MvPolynomial σ A)
Goal: (MvPolynomial.C a * φ).vars = φ.vars
-- MvPolynomial.vars_sum_subset
theorem vars_sum_subset [DecidableEq σ] :
    (∑ i ∈ t, φ i).vars ⊆ Finset.biUnion t fun i => (φ i).vars 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {ι : Type u_3} (t : Finset ι) (φ : ι → MvPolynomial σ R) [DecidableEq σ]
Goal: (∑ i ∈ t, φ i).vars ⊆ t.biUnion fun i => (φ i).vars
-- MvPolynomial.vars_sum_of_disjoint
theorem vars_sum_of_disjoint [DecidableEq σ] (h : Pairwise <| (Disjoint on fun i => (φ i).vars)) :
    (∑ i ∈ t, φ i).vars = Finset.biUnion t fun i => (φ i).vars 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] {ι : Type u_3} (t : Finset ι) (φ : ι → MvPolynomial σ R) [DecidableEq σ] (h : Pairwise (Disjoint on fun i => (φ i).vars))
Goal: (∑ i ∈ t, φ i).vars = t.biUnion fun i => (φ i).vars
-- MvPolynomial.vars_map
theorem vars_map : (map f p).vars ⊆ p.vars 
Arguments: {R : Type u} {S : Type v} {σ : Type u_1} [CommSemiring R] (p : MvPolynomial σ R) [CommSemiring S] (f : R →+* S)
Goal: ((MvPolynomial.map f) p).vars ⊆ p.vars
-- MvPolynomial.vars_map_of_injective
theorem vars_map_of_injective (hf : Injective f) : (map f p).vars = p.vars 
Arguments: {R : Type u} {S : Type v} {σ : Type u_1} [CommSemiring R] (p : MvPolynomial σ R) [CommSemiring S] {f : R →+* S} (hf : Function.Injective ⇑f)
Goal: ((MvPolynomial.map f) p).vars = p.vars
-- MvPolynomial.vars_monomial_single
theorem vars_monomial_single (i : σ) {e : ℕ} {r : R} (he : e ≠ 0) (hr : r ≠ 0) :
    (monomial (Finsupp.single i e) r).vars = {i} 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (i : σ) {e : ℕ} {r : R} (he : e ≠ 0) (hr : r ≠ 0)
Goal: ((MvPolynomial.monomial (Finsupp.single i e)) r).vars = {i}
-- MvPolynomial.vars_eq_support_biUnion_support
theorem vars_eq_support_biUnion_support [DecidableEq σ] :
    p.vars = p.support.biUnion Finsupp.support 
Arguments: {R : Type u} {σ : Type u_1} [CommSemiring R] (p : MvPolynomial σ R) [DecidableEq σ]
Goal: p.vars = p.support.biUnion Finsupp.support
-- MvPolynomial.eval₂Hom_eq_constantCoeff_of_vars
theorem eval₂Hom_eq_constantCoeff_of_vars (f : R →+* S) {g : σ → S} {p : MvPolynomial σ R}
    (hp : ∀ i ∈ p.vars, g i = 0) : eval₂Hom f g p = f (constantCoeff p) 
Arguments: {R : Type u} {S : Type v} {σ : Type u_1} [CommSemiring R] [CommSemiring S] (f : R →+* S) {g : σ → S} {p : MvPolynomial σ R} (hp : ∀ i ∈ p.vars, g i = 0)
Goal: (MvPolynomial.eval₂Hom f g) p = f (MvPolynomial.constantCoeff p)
-- MvPolynomial.aeval_eq_constantCoeff_of_vars
theorem aeval_eq_constantCoeff_of_vars [Algebra R S] {g : σ → S} {p : MvPolynomial σ R}
    (hp : ∀ i ∈ p.vars, g i = 0) : aeval g p = algebraMap _ _ (constantCoeff p) 
Arguments: {R : Type u} {S : Type v} {σ : Type u_1} [CommSemiring R] [CommSemiring S] [Algebra R S] {g : σ → S} {p : MvPolynomial σ R} (hp : ∀ i ∈ p.vars, g i = 0)
Goal: (MvPolynomial.aeval g) p = (algebraMap R S) (MvPolynomial.constantCoeff p)
-- MvPolynomial.eval₂Hom_congr'
theorem eval₂Hom_congr' {f₁ f₂ : R →+* S} {g₁ g₂ : σ → S} {p₁ p₂ : MvPolynomial σ R} :
    f₁ = f₂ →
      (∀ i, i ∈ p₁.vars → i ∈ p₂.vars → g₁ i = g₂ i) →
        p₁ = p₂ → eval₂Hom f₁ g₁ p₁ = eval₂Hom f₂ g₂ p₂ 
Arguments: {R : Type u} {S : Type v} {σ : Type u_1} [CommSemiring R] [CommSemiring S] {f₁ f₂ : R →+* S} {g₁ g₂ : σ → S} {p₁ p₂ : MvPolynomial σ R}
Goal: f₁ = f₂ →
  (∀ i ∈ p₁.vars, i ∈ p₂.vars → g₁ i = g₂ i) →
    p₁ = p₂ → (MvPolynomial.eval₂Hom f₁ g₁) p₁ = (MvPolynomial.eval₂Hom f₂ g₂) p₂
-- MvPolynomial.hom_congr_vars
theorem hom_congr_vars {f₁ f₂ : MvPolynomial σ R →+* S} {p₁ p₂ : MvPolynomial σ R}
    (hC : f₁.comp C = f₂.comp C) (hv : ∀ i, i ∈ p₁.vars → i ∈ p₂.vars → f₁ (X i) = f₂ (X i))
    (hp : p₁ = p₂) : f₁ p₁ = f₂ p₂ 
Arguments: {R : Type u} {S : Type v} {σ : Type u_1} [CommSemiring R] [CommSemiring S] {f₁ f₂ : MvPolynomial σ R →+* S} {p₁ p₂ : MvPolynomial σ R} (hC : f₁.comp MvPolynomial.C = f₂.comp MvPolynomial.C) (hv : ∀ i ∈ p₁.vars, i ∈ p₂.vars → f₁ (MvPolynomial.X i) = f₂ (MvPolynomial.X i)) (hp : p₁ = p₂)
Goal: f₁ p₁ = f₂ p₂
-- MvPolynomial.exists_rename_eq_of_vars_subset_range
theorem exists_rename_eq_of_vars_subset_range (p : MvPolynomial σ R) (f : τ → σ) (hfi : Injective f)
    (hf : ↑p.vars ⊆ Set.range f) : ∃ q : MvPolynomial τ R, rename f q = p 
Arguments: {R : Type u} {σ : Type u_1} {τ : Type u_2} [CommSemiring R] (p : MvPolynomial σ R) (f : τ → σ) (hfi : Function.Injective f) (hf : ↑p.vars ⊆ Set.range f)
Goal: ∃ q, (MvPolynomial.rename f) q = p
-- MvPolynomial.vars_rename
theorem vars_rename [DecidableEq τ] (f : σ → τ) (φ : MvPolynomial σ R) :
    (rename f φ).vars ⊆ φ.vars.image f 
Arguments: {R : Type u} {σ : Type u_1} {τ : Type u_2} [CommSemiring R] [DecidableEq τ] (f : σ → τ) (φ : MvPolynomial σ R)
Goal: ((MvPolynomial.rename f) φ).vars ⊆ Finset.image f φ.vars
-- MvPolynomial.mem_vars_rename
theorem mem_vars_rename (f : σ → τ) (φ : MvPolynomial σ R) {j : τ} (h : j ∈ (rename f φ).vars) :
    ∃ i : σ, i ∈ φ.vars ∧ f i = j 
Arguments: {R : Type u} {σ : Type u_1} {τ : Type u_2} [CommSemiring R] (f : σ → τ) (φ : MvPolynomial σ R) {j : τ} (h : j ∈ ((MvPolynomial.rename f) φ).vars)
Goal: ∃ i ∈ φ.vars, f i = j
-- star_nnratCast
@[simp, norm_cast]
lemma star_nnratCast [DivisionSemiring R] [StarRing R] (q : ℚ≥0) : star (q : R) = q 
Arguments: {R : Type u_1} [DivisionSemiring R] [StarRing R] (q : ℚ≥0)
Goal: star ↑q = ↑q
-- star_ratCast
@[simp, norm_cast]
theorem star_ratCast [DivisionRing R] [StarRing R] (r : ℚ) : star (r : R) = r 
Arguments: {R : Type u_1} [DivisionRing R] [StarRing R] (r : ℚ)
Goal: star ↑r = ↑r
-- MvPolynomial.rename_C
theorem rename_C (f : σ → τ) (r : R) : rename f (C r) = C r 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] (f : σ → τ) (r : R)
Goal: (MvPolynomial.rename f) (MvPolynomial.C r) = MvPolynomial.C r
-- MvPolynomial.rename_X
@[simp]
theorem rename_X (f : σ → τ) (i : σ) : rename f (X i : MvPolynomial σ R) = X (f i) 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] (f : σ → τ) (i : σ)
Goal: (MvPolynomial.rename f) (MvPolynomial.X i) = MvPolynomial.X (f i)
-- MvPolynomial.map_rename
theorem map_rename (f : R →+* S) (g : σ → τ) (p : MvPolynomial σ R) :
    map f (rename g p) = rename g (map f p) 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} {S : Type u_5} [CommSemiring R] [CommSemiring S] (f : R →+* S) (g : σ → τ) (p : MvPolynomial σ R)
Goal: (MvPolynomial.map f) ((MvPolynomial.rename g) p) = (MvPolynomial.rename g) ((MvPolynomial.map f) p)
-- MvPolynomial.rename_rename
@[simp]
theorem rename_rename (f : σ → τ) (g : τ → α) (p : MvPolynomial σ R) :
    rename g (rename f p) = rename (g ∘ f) p 
Arguments: {σ : Type u_1} {τ : Type u_2} {α : Type u_3} {R : Type u_4} [CommSemiring R] (f : σ → τ) (g : τ → α) (p : MvPolynomial σ R)
Goal: (MvPolynomial.rename g) ((MvPolynomial.rename f) p) = (MvPolynomial.rename (g ∘ f)) p
-- MvPolynomial.rename_id
@[simp]
theorem rename_id (p : MvPolynomial σ R) : rename id p = p 
Arguments: {σ : Type u_1} {R : Type u_4} [CommSemiring R] (p : MvPolynomial σ R)
Goal: (MvPolynomial.rename id) p = p
-- MvPolynomial.rename_monomial
theorem rename_monomial (f : σ → τ) (d : σ →₀ ℕ) (r : R) :
    rename f (monomial d r) = monomial (d.mapDomain f) r 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] (f : σ → τ) (d : σ →₀ ℕ) (r : R)
Goal: (MvPolynomial.rename f) ((MvPolynomial.monomial d) r) = (MvPolynomial.monomial (Finsupp.mapDomain f d)) r
-- MvPolynomial.rename_eq
theorem rename_eq (f : σ → τ) (p : MvPolynomial σ R) :
    rename f p = Finsupp.mapDomain (Finsupp.mapDomain f) p 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] (f : σ → τ) (p : MvPolynomial σ R)
Goal: (MvPolynomial.rename f) p = Finsupp.mapDomain (Finsupp.mapDomain f) p
-- MvPolynomial.rename_injective
theorem rename_injective (f : σ → τ) (hf : Function.Injective f) :
    Function.Injective (rename f : MvPolynomial σ R → MvPolynomial τ R) 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] (f : σ → τ) (hf : Function.Injective f)
Goal: Function.Injective ⇑(MvPolynomial.rename f)
-- MvPolynomial.killCompl_C
theorem killCompl_C (r : R) : killCompl hf (C r) = C r 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] {f : σ → τ} (hf : Function.Injective f) (r : R)
Goal: (MvPolynomial.killCompl hf) (MvPolynomial.C r) = MvPolynomial.C r
-- MvPolynomial.killCompl_comp_rename
theorem killCompl_comp_rename : (killCompl hf).comp (rename f) = AlgHom.id R _ 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] {f : σ → τ} (hf : Function.Injective f)
Goal: (MvPolynomial.killCompl hf).comp (MvPolynomial.rename f) = AlgHom.id R (MvPolynomial σ R)
-- MvPolynomial.killCompl_rename_app
@[simp]
theorem killCompl_rename_app (p : MvPolynomial σ R) : killCompl hf (rename f p) = p 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] {f : σ → τ} (hf : Function.Injective f) (p : MvPolynomial σ R)
Goal: (MvPolynomial.killCompl hf) ((MvPolynomial.rename f) p) = p
-- MvPolynomial.renameEquiv_apply
@[simps apply]
def renameEquiv (f : σ ≃ τ) : MvPolynomial σ R ≃ₐ[R] MvPolynomial τ R 
Arguments: {σ : Type u_1} {τ : Type u_2} (R : Type u_4) [CommSemiring R] (f : σ ≃ τ) (a : MvPolynomial σ R)
Goal: (MvPolynomial.renameEquiv R f) a = (MvPolynomial.rename ⇑f) a
-- MvPolynomial.renameEquiv_refl
@[simp]
theorem renameEquiv_refl : renameEquiv R (Equiv.refl σ) = AlgEquiv.refl 
Arguments: {σ : Type u_1} (R : Type u_4) [CommSemiring R]
Goal: MvPolynomial.renameEquiv R (Equiv.refl σ) = AlgEquiv.refl
-- MvPolynomial.renameEquiv_symm
@[simp]
theorem renameEquiv_symm (f : σ ≃ τ) : (renameEquiv R f).symm = renameEquiv R f.symm 
Arguments: {σ : Type u_1} {τ : Type u_2} (R : Type u_4) [CommSemiring R] (f : σ ≃ τ)
Goal: (MvPolynomial.renameEquiv R f).symm = MvPolynomial.renameEquiv R f.symm
-- MvPolynomial.renameEquiv_trans
@[simp]
theorem renameEquiv_trans (e : σ ≃ τ) (f : τ ≃ α) :
    (renameEquiv R e).trans (renameEquiv R f) = renameEquiv R (e.trans f) 
Arguments: {σ : Type u_1} {τ : Type u_2} {α : Type u_3} (R : Type u_4) [CommSemiring R] (e : σ ≃ τ) (f : τ ≃ α)
Goal: (MvPolynomial.renameEquiv R e).trans (MvPolynomial.renameEquiv R f) = MvPolynomial.renameEquiv R (e.trans f)
-- MvPolynomial.eval₂_rename
theorem eval₂_rename : (rename k p).eval₂ f g = p.eval₂ f (g ∘ k) 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} {S : Type u_5} [CommSemiring R] [CommSemiring S] (f : R →+* S) (k : σ → τ) (g : τ → S) (p : MvPolynomial σ R)
Goal: MvPolynomial.eval₂ f g ((MvPolynomial.rename k) p) = MvPolynomial.eval₂ f (g ∘ k) p
-- MvPolynomial.eval_rename
theorem eval_rename (g : τ → R) (p : MvPolynomial σ R) : eval g (rename k p) = eval (g ∘ k) p 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] (k : σ → τ) (g : τ → R) (p : MvPolynomial σ R)
Goal: (MvPolynomial.eval g) ((MvPolynomial.rename k) p) = (MvPolynomial.eval (g ∘ k)) p
-- MvPolynomial.eval₂Hom_rename
theorem eval₂Hom_rename : eval₂Hom f g (rename k p) = eval₂Hom f (g ∘ k) p 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} {S : Type u_5} [CommSemiring R] [CommSemiring S] (f : R →+* S) (k : σ → τ) (g : τ → S) (p : MvPolynomial σ R)
Goal: (MvPolynomial.eval₂Hom f g) ((MvPolynomial.rename k) p) = (MvPolynomial.eval₂Hom f (g ∘ k)) p
-- MvPolynomial.aeval_rename
theorem aeval_rename [Algebra R S] : aeval g (rename k p) = aeval (g ∘ k) p 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} {S : Type u_5} [CommSemiring R] [CommSemiring S] (k : σ → τ) (g : τ → S) (p : MvPolynomial σ R) [Algebra R S]
Goal: (MvPolynomial.aeval g) ((MvPolynomial.rename k) p) = (MvPolynomial.aeval (g ∘ k)) p
-- MvPolynomial.rename_eval₂
theorem rename_eval₂ (g : τ → MvPolynomial σ R) :
    rename k (p.eval₂ C (g ∘ k)) = (rename k p).eval₂ C (rename k ∘ g) 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] (k : σ → τ) (p : MvPolynomial σ R) (g : τ → MvPolynomial σ R)
Goal: (MvPolynomial.rename k) (MvPolynomial.eval₂ MvPolynomial.C (g ∘ k) p) =
  MvPolynomial.eval₂ MvPolynomial.C (⇑(MvPolynomial.rename k) ∘ g) ((MvPolynomial.rename k) p)
-- MvPolynomial.rename_prod_mk_eval₂
theorem rename_prod_mk_eval₂ (j : τ) (g : σ → MvPolynomial σ R) :
    rename (Prod.mk j) (p.eval₂ C g) = p.eval₂ C fun x => rename (Prod.mk j) (g x) 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] (p : MvPolynomial σ R) (j : τ) (g : σ → MvPolynomial σ R)
Goal: (MvPolynomial.rename (Prod.mk j)) (MvPolynomial.eval₂ MvPolynomial.C g p) =
  MvPolynomial.eval₂ MvPolynomial.C (fun x => (MvPolynomial.rename (Prod.mk j)) (g x)) p
-- MvPolynomial.eval₂_rename_prod_mk
theorem eval₂_rename_prod_mk (g : σ × τ → S) (i : σ) (p : MvPolynomial τ R) :
    (rename (Prod.mk i) p).eval₂ f g = eval₂ f (fun j => g (i, j)) p 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} {S : Type u_5} [CommSemiring R] [CommSemiring S] (f : R →+* S) (g : σ × τ → S) (i : σ) (p : MvPolynomial τ R)
Goal: MvPolynomial.eval₂ f g ((MvPolynomial.rename (Prod.mk i)) p) = MvPolynomial.eval₂ f (fun j => g (i, j)) p
-- MvPolynomial.eval_rename_prod_mk
theorem eval_rename_prod_mk (g : σ × τ → R) (i : σ) (p : MvPolynomial τ R) :
    eval g (rename (Prod.mk i) p) = eval (fun j => g (i, j)) p 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] (g : σ × τ → R) (i : σ) (p : MvPolynomial τ R)
Goal: (MvPolynomial.eval g) ((MvPolynomial.rename (Prod.mk i)) p) = (MvPolynomial.eval fun j => g (i, j)) p
-- MvPolynomial.exists_finset_rename
theorem exists_finset_rename (p : MvPolynomial σ R) :
    ∃ (s : Finset σ) (q : MvPolynomial { x // x ∈ s } R), p = rename (↑) q 
Arguments: {σ : Type u_1} {R : Type u_4} [CommSemiring R] (p : MvPolynomial σ R)
Goal: ∃ s q, p = (MvPolynomial.rename Subtype.val) q
-- MvPolynomial.exists_finset_rename₂
theorem exists_finset_rename₂ (p₁ p₂ : MvPolynomial σ R) :
    ∃ (s : Finset σ) (q₁ q₂ : MvPolynomial s R), p₁ = rename (↑) q₁ ∧ p₂ = rename (↑) q₂ 
Arguments: {σ : Type u_1} {R : Type u_4} [CommSemiring R] (p₁ p₂ : MvPolynomial σ R)
Goal: ∃ s q₁ q₂, p₁ = (MvPolynomial.rename Subtype.val) q₁ ∧ p₂ = (MvPolynomial.rename Subtype.val) q₂
-- MvPolynomial.exists_fin_rename
theorem exists_fin_rename (p : MvPolynomial σ R) :
    ∃ (n : ℕ) (f : Fin n → σ) (_hf : Injective f) (q : MvPolynomial (Fin n) R), p = rename f q 
Arguments: {σ : Type u_1} {R : Type u_4} [CommSemiring R] (p : MvPolynomial σ R)
Goal: ∃ n f, ∃ (_ : Function.Injective f), ∃ q, p = (MvPolynomial.rename f) q
-- MvPolynomial.eval₂_cast_comp
theorem eval₂_cast_comp (f : σ → τ) (c : ℤ →+* R) (g : τ → R) (p : MvPolynomial σ ℤ) :
    eval₂ c (g ∘ f) p = eval₂ c g (rename f p) 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] (f : σ → τ) (c : ℤ →+* R) (g : τ → R) (p : MvPolynomial σ ℤ)
Goal: MvPolynomial.eval₂ c (g ∘ f) p = MvPolynomial.eval₂ c g ((MvPolynomial.rename f) p)
-- MvPolynomial.coeff_rename_mapDomain
@[simp]
theorem coeff_rename_mapDomain (f : σ → τ) (hf : Injective f) (φ : MvPolynomial σ R) (d : σ →₀ ℕ) :
    (rename f φ).coeff (d.mapDomain f) = φ.coeff d 
Arguments: {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [CommSemiring R] (f : σ → τ) (hf : Function.Injective f) (φ : MvPolynomial σ R) (d : σ →₀ ℕ)
Goal: MvPolynomial.coeff (Finsupp.mapDomain f d) ((MvPolynomial.rename f) φ) = MvPolynomial.coeff d φ