ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Subfield.mem_map
@[simp]
theorem mem_map {f : K →+* L} {s : Subfield K} {y : L} : y ∈ s.map f ↔ ∃ x ∈ s, f x = y 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] {f : K →+* L} {s : Subfield K} {y : L}
Goal: y ∈ Subfield.map f s ↔ ∃ x ∈ s, f x = y
-- Subfield.map_map
theorem map_map (g : L →+* M) (f : K →+* L) : (s.map f).map g = s.map (g.comp f) 
Arguments: {K : Type u} {L : Type v} {M : Type w} [DivisionRing K] [DivisionRing L] [DivisionRing M] (s : Subfield K) (g : L →+* M) (f : K →+* L)
Goal: Subfield.map g (Subfield.map f s) = Subfield.map (g.comp f) s
-- Subfield.map_le_iff_le_comap
theorem map_le_iff_le_comap {f : K →+* L} {s : Subfield K} {t : Subfield L} :
    s.map f ≤ t ↔ s ≤ t.comap f 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] {f : K →+* L} {s : Subfield K} {t : Subfield L}
Goal: Subfield.map f s ≤ t ↔ s ≤ Subfield.comap f t
-- Subfield.gc_map_comap
theorem gc_map_comap (f : K →+* L) : GaloisConnection (map f) (comap f) 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (f : K →+* L)
Goal: GaloisConnection (Subfield.map f) (Subfield.comap f)
-- RingHom.coe_fieldRange
@[simp]
theorem coe_fieldRange : (f.fieldRange : Set L) = Set.range f 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (f : K →+* L)
Goal: ↑f.fieldRange = Set.range ⇑f
-- RingHom.mem_fieldRange
@[simp]
theorem mem_fieldRange {f : K →+* L} {y : L} : y ∈ f.fieldRange ↔ ∃ x, f x = y 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] {f : K →+* L} {y : L}
Goal: y ∈ f.fieldRange ↔ ∃ x, f x = y
-- RingHom.fieldRange_eq_map
theorem fieldRange_eq_map : f.fieldRange = Subfield.map f ⊤ 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (f : K →+* L)
Goal: f.fieldRange = Subfield.map f ⊤
-- RingHom.map_fieldRange
theorem map_fieldRange : f.fieldRange.map g = (g.comp f).fieldRange 
Arguments: {K : Type u} {L : Type v} {M : Type w} [DivisionRing K] [DivisionRing L] [DivisionRing M] (g : L →+* M) (f : K →+* L)
Goal: Subfield.map g f.fieldRange = (g.comp f).fieldRange
-- Subfield.coe_inf
@[simp]
theorem coe_inf (p p' : Subfield K) : ((p ⊓ p' : Subfield K) : Set K) = p.carrier ∩ p'.carrier 
Arguments: {K : Type u} [DivisionRing K] (p p' : Subfield K)
Goal: ↑(p ⊓ p') = p.carrier ∩ p'.carrier
-- Subfield.mem_inf
@[simp]
theorem mem_inf {p p' : Subfield K} {x : K} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' 
Arguments: {K : Type u} [DivisionRing K] {p p' : Subfield K} {x : K}
Goal: x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'
-- Subfield.coe_sInf
@[simp, norm_cast]
theorem coe_sInf (S : Set (Subfield K)) : ((sInf S : Subfield K) : Set K) = ⋂ s ∈ S, ↑s 
Arguments: {K : Type u} [DivisionRing K] (S : Set (Subfield K))
Goal: ↑(sInf S) = ⋂ s ∈ S, ↑s
-- Subfield.mem_sInf
theorem mem_sInf {S : Set (Subfield K)} {x : K} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p 
Arguments: {K : Type u} [DivisionRing K] {S : Set (Subfield K)} {x : K}
Goal: x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p
-- Subfield.sInf_toSubring
@[simp]
theorem sInf_toSubring (s : Set (Subfield K)) :
    (sInf s).toSubring = ⨅ t ∈ s, Subfield.toSubring t 
Arguments: {K : Type u} [DivisionRing K] (s : Set (Subfield K))
Goal: (sInf s).toSubring = ⨅ t ∈ s, t.toSubring
-- Subfield.isGLB_sInf
theorem isGLB_sInf (S : Set (Subfield K)) : IsGLB S (sInf S) 
Arguments: {K : Type u} [DivisionRing K] (S : Set (Subfield K))
Goal: IsGLB S (sInf S)
-- Subfield.mem_closure
theorem mem_closure {x : K} {s : Set K} : x ∈ closure s ↔ ∀ S : Subfield K, s ⊆ S → x ∈ S 
Arguments: {K : Type u} [DivisionRing K] {x : K} {s : Set K}
Goal: x ∈ Subfield.closure s ↔ ∀ (S : Subfield K), s ⊆ ↑S → x ∈ S
-- Subfield.subset_closure
@[simp, aesop safe 20 apply (rule_sets := [SetLike])]
theorem subset_closure {s : Set K} : s ⊆ closure s 
Arguments: {K : Type u} [DivisionRing K] {s : Set K}
Goal: s ⊆ ↑(Subfield.closure s)
-- Subfield.subring_closure_le
theorem subring_closure_le (s : Set K) : Subring.closure s ≤ (closure s).toSubring 
Arguments: {K : Type u} [DivisionRing K] (s : Set K)
Goal: Subring.closure s ≤ (Subfield.closure s).toSubring
-- Subfield.not_mem_of_not_mem_closure
theorem not_mem_of_not_mem_closure {s : Set K} {P : K} (hP : P ∉ closure s) : P ∉ s 
Arguments: {K : Type u} [DivisionRing K] {s : Set K} {P : K} (hP : P ∉ Subfield.closure s)
Goal: P ∉ s
-- Subfield.closure_le
@[simp]
theorem closure_le {s : Set K} {t : Subfield K} : closure s ≤ t ↔ s ⊆ t 
Arguments: {K : Type u} [DivisionRing K] {s : Set K} {t : Subfield K}
Goal: Subfield.closure s ≤ t ↔ s ⊆ ↑t
-- Subfield.closure_mono
theorem closure_mono ⦃s t : Set K⦄ (h : s ⊆ t) : closure s ≤ closure t 
Arguments: {K : Type u} [DivisionRing K] ⦃s t : Set K⦄ (h : s ⊆ t)
Goal: Subfield.closure s ≤ Subfield.closure t
-- Subfield.closure_eq_of_le
theorem closure_eq_of_le {s : Set K} {t : Subfield K} (h₁ : s ⊆ t) (h₂ : t ≤ closure s) :
    closure s = t 
Arguments: {K : Type u} [DivisionRing K] {s : Set K} {t : Subfield K} (h₁ : s ⊆ ↑t) (h₂ : t ≤ Subfield.closure s)
Goal: Subfield.closure s = t
-- Subfield.closure_induction
@[elab_as_elim]
theorem closure_induction {s : Set K} {p : K → Prop} {x} (h : x ∈ closure s) (mem : ∀ x ∈ s, p x)
    (one : p 1) (add : ∀ x y, p x → p y → p (x + y)) (neg : ∀ x, p x → p (-x))
    (inv : ∀ x, p x → p x⁻¹) (mul : ∀ x y, p x → p y → p (x * y)) : p x 
Arguments: {K : Type u} [DivisionRing K] {s : Set K} {p : K → Prop} {x : K} (h : x ∈ Subfield.closure s) (mem : ∀ x ∈ s, p x) (one : p 1) (add : ∀ (x y : K), p x → p y → p (x + y)) (neg : ∀ (x : K), p x → p (-x)) (inv : ∀ (x : K), p x → p x⁻¹) (mul : ∀ (x y : K), p x → p y → p (x * y))
Goal: p x
-- Subfield.closure_eq
theorem closure_eq (s : Subfield K) : closure (s : Set K) = s 
Arguments: {K : Type u} [DivisionRing K] (s : Subfield K)
Goal: Subfield.closure ↑s = s
-- Subfield.closure_empty
@[simp]
theorem closure_empty : closure (∅ : Set K) = ⊥ 
Arguments: {K : Type u} [DivisionRing K]
Goal: Subfield.closure ∅ = ⊥
-- Subfield.closure_univ
@[simp]
theorem closure_univ : closure (Set.univ : Set K) = ⊤ 
Arguments: {K : Type u} [DivisionRing K]
Goal: Subfield.closure Set.univ = ⊤
-- Subfield.closure_union
theorem closure_union (s t : Set K) : closure (s ∪ t) = closure s ⊔ closure t 
Arguments: {K : Type u} [DivisionRing K] (s t : Set K)
Goal: Subfield.closure (s ∪ t) = Subfield.closure s ⊔ Subfield.closure t
-- Subfield.closure_iUnion
theorem closure_iUnion {ι} (s : ι → Set K) : closure (⋃ i, s i) = ⨆ i, closure (s i) 
Arguments: {K : Type u} [DivisionRing K] {ι : Sort u_1} (s : ι → Set K)
Goal: Subfield.closure (⋃ i, s i) = ⨆ i, Subfield.closure (s i)
-- Subfield.closure_sUnion
theorem closure_sUnion (s : Set (Set K)) : closure (⋃₀ s) = ⨆ t ∈ s, closure t 
Arguments: {K : Type u} [DivisionRing K] (s : Set (Set K))
Goal: Subfield.closure (⋃₀ s) = ⨆ t ∈ s, Subfield.closure t
-- Subfield.map_sup
theorem map_sup (s t : Subfield K) (f : K →+* L) : (s ⊔ t).map f = s.map f ⊔ t.map f 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (s t : Subfield K) (f : K →+* L)
Goal: Subfield.map f (s ⊔ t) = Subfield.map f s ⊔ Subfield.map f t
-- Subfield.map_iSup
theorem map_iSup {ι : Sort*} (f : K →+* L) (s : ι → Subfield K) :
    (iSup s).map f = ⨆ i, (s i).map f 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] {ι : Sort u_1} (f : K →+* L) (s : ι → Subfield K)
Goal: Subfield.map f (iSup s) = ⨆ i, Subfield.map f (s i)
-- Subfield.comap_inf
theorem comap_inf (s t : Subfield L) (f : K →+* L) : (s ⊓ t).comap f = s.comap f ⊓ t.comap f 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (s t : Subfield L) (f : K →+* L)
Goal: Subfield.comap f (s ⊓ t) = Subfield.comap f s ⊓ Subfield.comap f t
-- Subfield.comap_iInf
theorem comap_iInf {ι : Sort*} (f : K →+* L) (s : ι → Subfield L) :
    (iInf s).comap f = ⨅ i, (s i).comap f 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] {ι : Sort u_1} (f : K →+* L) (s : ι → Subfield L)
Goal: Subfield.comap f (iInf s) = ⨅ i, Subfield.comap f (s i)
-- Subfield.map_bot
@[simp]
theorem map_bot (f : K →+* L) : (⊥ : Subfield K).map f = ⊥ 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (f : K →+* L)
Goal: Subfield.map f ⊥ = ⊥
-- Subfield.comap_top
@[simp]
theorem comap_top (f : K →+* L) : (⊤ : Subfield L).comap f = ⊤ 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (f : K →+* L)
Goal: Subfield.comap f ⊤ = ⊤
-- Subfield.mem_iSup_of_directed
theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Subfield K} (hS : Directed (· ≤ ·) S)
    {x : K} : (x ∈ ⨆ i, S i) ↔ ∃ i, x ∈ S i 
Arguments: {K : Type u} [DivisionRing K] {ι : Sort u_1} [hι : Nonempty ι] {S : ι → Subfield K} (hS : Directed (fun x x_1 => x ≤ x_1) S) {x : K}
Goal: x ∈ ⨆ i, S i ↔ ∃ i, x ∈ S i
-- Subfield.coe_iSup_of_directed
theorem coe_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Subfield K} (hS : Directed (· ≤ ·) S) :
    ((⨆ i, S i : Subfield K) : Set K) = ⋃ i, ↑(S i) 
Arguments: {K : Type u} [DivisionRing K] {ι : Sort u_1} [hι : Nonempty ι] {S : ι → Subfield K} (hS : Directed (fun x x_1 => x ≤ x_1) S)
Goal: ↑(⨆ i, S i) = ⋃ i, ↑(S i)
-- Subfield.mem_sSup_of_directedOn
theorem mem_sSup_of_directedOn {S : Set (Subfield K)} (Sne : S.Nonempty) (hS : DirectedOn (· ≤ ·) S)
    {x : K} : x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s 
Arguments: {K : Type u} [DivisionRing K] {S : Set (Subfield K)} (Sne : S.Nonempty) (hS : DirectedOn (fun x x_1 => x ≤ x_1) S) {x : K}
Goal: x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s
-- Subfield.coe_sSup_of_directedOn
theorem coe_sSup_of_directedOn {S : Set (Subfield K)} (Sne : S.Nonempty)
    (hS : DirectedOn (· ≤ ·) S) : (↑(sSup S) : Set K) = ⋃ s ∈ S, ↑s 
Arguments: {K : Type u} [DivisionRing K] {S : Set (Subfield K)} (Sne : S.Nonempty) (hS : DirectedOn (fun x x_1 => x ≤ x_1) S)
Goal: ↑(sSup S) = ⋃ s ∈ S, ↑s
-- RingHom.coe_rangeRestrictField
@[simp]
theorem coe_rangeRestrictField (f : K →+* L) (x : K) : (f.rangeRestrictField x : L) = f x 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (f : K →+* L) (x : K)
Goal: ↑(f.rangeRestrictField x) = f x
-- RingHom.eqOn_field_closure
theorem eqOn_field_closure {f g : K →+* L} {s : Set K} (h : Set.EqOn f g s) :
    Set.EqOn f g (closure s) 
Arguments: {K : Type u} [DivisionRing K] {L : Type v} [Semiring L] {f g : K →+* L} {s : Set K} (h : Set.EqOn (⇑f) (⇑g) s)
Goal: Set.EqOn ⇑f ⇑g ↑(Subfield.closure s)
-- RingHom.eq_of_eqOn_subfield_top
theorem eq_of_eqOn_subfield_top {f g : K →+* L} (h : Set.EqOn f g (⊤ : Subfield K)) : f = g 
Arguments: {K : Type u} [DivisionRing K] {L : Type v} [Semiring L] {f g : K →+* L} (h : Set.EqOn ⇑f ⇑g ↑⊤)
Goal: f = g
-- RingHom.eq_of_eqOn_of_field_closure_eq_top
theorem eq_of_eqOn_of_field_closure_eq_top {s : Set K} (hs : closure s = ⊤) {f g : K →+* L}
    (h : s.EqOn f g) : f = g 
Arguments: {K : Type u} [DivisionRing K] {L : Type v} [Semiring L] {s : Set K} (hs : Subfield.closure s = ⊤) {f g : K →+* L} (h : Set.EqOn (⇑f) (⇑g) s)
Goal: f = g
-- RingHom.field_closure_preimage_le
theorem field_closure_preimage_le (f : K →+* L) (s : Set L) :
    closure (f ⁻¹' s) ≤ (closure s).comap f 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (f : K →+* L) (s : Set L)
Goal: Subfield.closure (⇑f ⁻¹' s) ≤ Subfield.comap f (Subfield.closure s)
-- RingHom.map_field_closure
theorem map_field_closure (f : K →+* L) (s : Set K) : (closure s).map f = closure (f '' s) 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (f : K →+* L) (s : Set K)
Goal: Subfield.map f (Subfield.closure s) = Subfield.closure (⇑f '' s)
-- Subfield.fieldRange_subtype
@[simp]
theorem fieldRange_subtype (s : Subfield K) : s.subtype.fieldRange = s 
Arguments: {K : Type u} [DivisionRing K] (s : Subfield K)
Goal: s.subtype.fieldRange = s
-- Subfield.closure_preimage_le
theorem closure_preimage_le (f : K →+* L) (s : Set L) : closure (f ⁻¹' s) ≤ (closure s).comap f 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (f : K →+* L) (s : Set L)
Goal: Subfield.closure (⇑f ⁻¹' s) ≤ Subfield.comap f (Subfield.closure s)
-- Subfield.multiset_prod_mem
protected theorem multiset_prod_mem (m : Multiset K) : (∀ a ∈ m, a ∈ s) → m.prod ∈ s 
Arguments: {K : Type u} [Field K] (s : Subfield K) (m : Multiset K)
Goal: (∀ a ∈ m, a ∈ s) → m.prod ∈ s
-- Subfield.prod_mem
protected theorem prod_mem {ι : Type*} {t : Finset ι} {f : ι → K} (h : ∀ c ∈ t, f c ∈ s) :
    (∏ i ∈ t, f i) ∈ s 
Arguments: {K : Type u} [Field K] (s : Subfield K) {ι : Type u_1} {t : Finset ι} {f : ι → K} (h : ∀ c ∈ t, f c ∈ s)
Goal: ∏ i ∈ t, f i ∈ s
-- _private.Mathlib.Algebra.Field.Subfield.0.Subfield.commClosure_eq_closure
private theorem commClosure_eq_closure {s : Set K} : commClosure s = closure s 
Arguments: {K : Type u} [Field K] {s : Set K}
Goal: Subfield.commClosure s = Subfield.closure s
-- Subfield.mem_closure_iff
theorem mem_closure_iff {s : Set K} {x} :
    x ∈ closure s ↔ ∃ y ∈ Subring.closure s, ∃ z ∈ Subring.closure s, y / z = x 
Arguments: {K : Type u} [Field K] {s : Set K} {x : K}
Goal: x ∈ Subfield.closure s ↔ ∃ y ∈ Subring.closure s, ∃ z ∈ Subring.closure s, y / z = x
-- Subfield.map_comap_eq
theorem map_comap_eq (f : K →+* L) (s : Subfield L) : (s.comap f).map f = s ⊓ f.fieldRange 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (f : K →+* L) (s : Subfield L)
Goal: Subfield.map f (Subfield.comap f s) = s ⊓ f.fieldRange
-- Subfield.map_comap_eq_self
theorem map_comap_eq_self
    {f : K →+* L} {s : Subfield L} (h : s ≤ f.fieldRange) : (s.comap f).map f = s 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] {f : K →+* L} {s : Subfield L} (h : s ≤ f.fieldRange)
Goal: Subfield.map f (Subfield.comap f s) = s
-- Subfield.map_comap_eq_self_of_surjective
theorem map_comap_eq_self_of_surjective
    {f : K →+* L} (hf : Function.Surjective f) (s : Subfield L) : (s.comap f).map f = s 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] {f : K →+* L} (hf : Function.Surjective ⇑f) (s : Subfield L)
Goal: Subfield.map f (Subfield.comap f s) = s
-- Subfield.comap_map
theorem comap_map (f : K →+* L) (s : Subfield K) : (s.map f).comap f = s 
Arguments: {K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] (f : K →+* L) (s : Subfield K)
Goal: Subfield.comap f (Subfield.map f s) = s
-- CochainComplex.mappingCone.triangle_obj₃
@[simps! obj₁ obj₂ obj₃ mor₁ mor₂]
noncomputable def triangle : Triangle (CochainComplex C ℤ) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L)
Goal: (CochainComplex.mappingCone.triangle φ).obj₃ = CochainComplex.mappingCone φ
-- CochainComplex.mappingCone.triangle_mor₁
@[simps! obj₁ obj₂ obj₃ mor₁ mor₂]
noncomputable def triangle : Triangle (CochainComplex C ℤ) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L)
Goal: (CochainComplex.mappingCone.triangle φ).mor₁ = φ
-- CochainComplex.mappingCone.triangle_mor₂
@[simps! obj₁ obj₂ obj₃ mor₁ mor₂]
noncomputable def triangle : Triangle (CochainComplex C ℤ) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L)
Goal: (CochainComplex.mappingCone.triangle φ).mor₂ = CochainComplex.mappingCone.inr φ
-- CochainComplex.mappingCone.triangle_obj₁
@[simps! obj₁ obj₂ obj₃ mor₁ mor₂]
noncomputable def triangle : Triangle (CochainComplex C ℤ) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L)
Goal: (CochainComplex.mappingCone.triangle φ).obj₁ = K
-- CochainComplex.mappingCone.triangle_obj₂
@[simps! obj₁ obj₂ obj₃ mor₁ mor₂]
noncomputable def triangle : Triangle (CochainComplex C ℤ) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L)
Goal: (CochainComplex.mappingCone.triangle φ).obj₂ = L
-- CochainComplex.mappingCone.inl_v_triangle_mor₃_f
@[reassoc (attr := simp)]
lemma inl_v_triangle_mor₃_f (p q : ℤ) (hpq : p + (-1) = q) :
    (inl φ).v p q hpq ≫ (triangle φ).mor₃.f q =
      -(K.shiftFunctorObjXIso 1 q p (by rw [← hpq, neg_add_cancel_right])).inv 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L) (p q : ℤ) (hpq : p + -1 = q)
Goal: (CochainComplex.mappingCone.inl φ).v p q hpq ≫ (CochainComplex.mappingCone.triangle φ).mor₃.f q =
  -(K.shiftFunctorObjXIso 1 q p ⋯).inv
-- CochainComplex.mappingCone.inr_f_triangle_mor₃_f
@[reassoc (attr := simp)]
lemma inr_f_triangle_mor₃_f (p : ℤ) : (inr φ).f p ≫ (triangle φ).mor₃.f p = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L) (p : ℤ)
Goal: (CochainComplex.mappingCone.inr φ).f p ≫ (CochainComplex.mappingCone.triangle φ).mor₃.f p = 0
-- CochainComplex.mappingCone.inr_triangleδ
@[reassoc (attr := simp)]
lemma inr_triangleδ : inr φ ≫ (triangle φ).mor₃ = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L)
Goal: CochainComplex.mappingCone.inr φ ≫ (CochainComplex.mappingCone.triangle φ).mor₃ = 0
-- CochainComplex.mappingCone.triangleMapOfHomotopy_comm₂
@[reassoc]
lemma triangleMapOfHomotopy_comm₂ :
    inr φ₁ ≫ mapOfHomotopy H = b ≫ inr φ₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} {φ₁ : K₁ ⟶ L₁} {φ₂ : K₂ ⟶ L₂} {a : K₁ ⟶ K₂} {b : L₁ ⟶ L₂} (H : Homotopy (φ₁ ≫ b) (a ≫ φ₂))
Goal: CochainComplex.mappingCone.inr φ₁ ≫ CochainComplex.mappingCone.mapOfHomotopy H = b ≫ CochainComplex.mappingCone.inr φ₂
-- CochainComplex.mappingCone.triangleMapOfHomotopy_comm₃
@[reassoc]
lemma triangleMapOfHomotopy_comm₃ :
    mapOfHomotopy H ≫ (triangle φ₂).mor₃ = (triangle φ₁).mor₃ ≫ a⟦1⟧' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} {φ₁ : K₁ ⟶ L₁} {φ₂ : K₂ ⟶ L₂} {a : K₁ ⟶ K₂} {b : L₁ ⟶ L₂} (H : Homotopy (φ₁ ≫ b) (a ≫ φ₂))
Goal: CochainComplex.mappingCone.mapOfHomotopy H ≫ (CochainComplex.mappingCone.triangle φ₂).mor₃ =
  (CochainComplex.mappingCone.triangle φ₁).mor₃ ≫ (CategoryTheory.shiftFunctor (CochainComplex C ℤ) 1).map a
-- CochainComplex.mappingCone.trianglehMapOfHomotopy_hom₁
@[simps]
noncomputable def trianglehMapOfHomotopy :
    triangleh φ₁ ⟶ triangleh φ₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} {φ₁ : K₁ ⟶ L₁} {φ₂ : K₂ ⟶ L₂} {a : K₁ ⟶ K₂} {b : L₁ ⟶ L₂} (H : Homotopy (φ₁ ≫ b) (a ≫ φ₂))
Goal: (CochainComplex.mappingCone.trianglehMapOfHomotopy H).hom₁ = (HomotopyCategory.quotient C (ComplexShape.up ℤ)).map a
-- CochainComplex.mappingCone.trianglehMapOfHomotopy_hom₂
@[simps]
noncomputable def trianglehMapOfHomotopy :
    triangleh φ₁ ⟶ triangleh φ₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} {φ₁ : K₁ ⟶ L₁} {φ₂ : K₂ ⟶ L₂} {a : K₁ ⟶ K₂} {b : L₁ ⟶ L₂} (H : Homotopy (φ₁ ≫ b) (a ≫ φ₂))
Goal: (CochainComplex.mappingCone.trianglehMapOfHomotopy H).hom₂ = (HomotopyCategory.quotient C (ComplexShape.up ℤ)).map b
-- CochainComplex.mappingCone.trianglehMapOfHomotopy_hom₃
@[simps]
noncomputable def trianglehMapOfHomotopy :
    triangleh φ₁ ⟶ triangleh φ₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} {φ₁ : K₁ ⟶ L₁} {φ₂ : K₂ ⟶ L₂} {a : K₁ ⟶ K₂} {b : L₁ ⟶ L₂} (H : Homotopy (φ₁ ≫ b) (a ≫ φ₂))
Goal: (CochainComplex.mappingCone.trianglehMapOfHomotopy H).hom₃ =
  (HomotopyCategory.quotient C (ComplexShape.up ℤ)).map (CochainComplex.mappingCone.mapOfHomotopy H)
-- CochainComplex.mappingCone.map_eq_mapOfHomotopy
lemma map_eq_mapOfHomotopy : map φ₁ φ₂ a b comm = mapOfHomotopy (Homotopy.ofEq comm) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} (φ₁ : K₁ ⟶ L₁) (φ₂ : K₂ ⟶ L₂) (a : K₁ ⟶ K₂) (b : L₁ ⟶ L₂) (comm : φ₁ ≫ b = a ≫ φ₂)
Goal: CochainComplex.mappingCone.map φ₁ φ₂ a b comm = CochainComplex.mappingCone.mapOfHomotopy (Homotopy.ofEq comm)
-- CochainComplex.mappingCone.map_id
lemma map_id : map φ φ (𝟙 _) (𝟙 _) (by rw [id_comp, comp_id]) = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L)
Goal: CochainComplex.mappingCone.map φ φ (𝟙 K) (𝟙 L) ⋯ = 𝟙 (CochainComplex.mappingCone φ)
-- CochainComplex.mappingCone.map_comp
@[reassoc]
lemma map_comp : map φ₁ φ₃ (a ≫ a') (b ≫ b') (by rw [reassoc_of% comm, comm', assoc]) =
    map φ₁ φ₂ a b comm ≫ map φ₂ φ₃ a' b' comm' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ K₃ L₃ : CochainComplex C ℤ} (φ₁ : K₁ ⟶ L₁) (φ₂ : K₂ ⟶ L₂) (φ₃ : K₃ ⟶ L₃) (a : K₁ ⟶ K₂) (b : L₁ ⟶ L₂) (comm : φ₁ ≫ b = a ≫ φ₂) (a' : K₂ ⟶ K₃) (b' : L₂ ⟶ L₃) (comm' : φ₂ ≫ b' = a' ≫ φ₃)
Goal: CochainComplex.mappingCone.map φ₁ φ₃ (a ≫ a') (b ≫ b') ⋯ =
  CochainComplex.mappingCone.map φ₁ φ₂ a b comm ≫ CochainComplex.mappingCone.map φ₂ φ₃ a' b' comm'
-- CochainComplex.mappingCone.triangleMap_hom₃
@[simps]
noncomputable def triangleMap :
    triangle φ₁ ⟶ triangle φ₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} (φ₁ : K₁ ⟶ L₁) (φ₂ : K₂ ⟶ L₂) (a : K₁ ⟶ K₂) (b : L₁ ⟶ L₂) (comm : φ₁ ≫ b = a ≫ φ₂)
Goal: (CochainComplex.mappingCone.triangleMap φ₁ φ₂ a b comm).hom₃ = CochainComplex.mappingCone.map φ₁ φ₂ a b comm
-- CochainComplex.mappingCone.triangleMap_hom₂
@[simps]
noncomputable def triangleMap :
    triangle φ₁ ⟶ triangle φ₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} (φ₁ : K₁ ⟶ L₁) (φ₂ : K₂ ⟶ L₂) (a : K₁ ⟶ K₂) (b : L₁ ⟶ L₂) (comm : φ₁ ≫ b = a ≫ φ₂)
Goal: (CochainComplex.mappingCone.triangleMap φ₁ φ₂ a b comm).hom₂ = b
-- CochainComplex.mappingCone.triangleMap_hom₁
@[simps]
noncomputable def triangleMap :
    triangle φ₁ ⟶ triangle φ₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} (φ₁ : K₁ ⟶ L₁) (φ₂ : K₂ ⟶ L₂) (a : K₁ ⟶ K₂) (b : L₁ ⟶ L₂) (comm : φ₁ ≫ b = a ≫ φ₂)
Goal: (CochainComplex.mappingCone.triangleMap φ₁ φ₂ a b comm).hom₁ = a
-- CochainComplex.mappingCone.rotateHomotopyEquiv_comm₂
@[reassoc (attr := simp)]
lemma rotateHomotopyEquiv_comm₂ :
    (HomotopyCategory.quotient _ _ ).map (triangle φ).mor₃ ≫
      (HomotopyCategory.quotient _ _ ).map (rotateHomotopyEquiv φ).hom =
      (HomotopyCategory.quotient _ _ ).map (inr (inr φ)) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L)
Goal: (HomotopyCategory.quotient C (ComplexShape.up ℤ)).map (CochainComplex.mappingCone.triangle φ).mor₃ ≫
    (HomotopyCategory.quotient C (ComplexShape.up ℤ)).map (CochainComplex.mappingCone.rotateHomotopyEquiv φ).hom =
  (HomotopyCategory.quotient C (ComplexShape.up ℤ)).map
    (CochainComplex.mappingCone.inr (CochainComplex.mappingCone.inr φ))