name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Grind.CommRing.Poly.mulConstC.go._unsafe_rec | Init.Grind.Ring.CommSolver | ℤ → ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly |
Sublattice.instLatticeCoe._proof_4 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : Lattice α] (L : Sublattice α) (x x_1 : ↥L), ↑(x ⊔ x_1) = ↑(x ⊔ x_1) |
Lean.Meta.CaseArraySizesSubgoal.ctorIdx | Lean.Meta.Match.CaseArraySizes | Lean.Meta.CaseArraySizesSubgoal → ℕ |
Int.Linear.dvd_solve_elim_cert.eq_1 | Init.Data.Int.Linear | ∀ (d₁ d₂ d : ℤ) (p : Int.Linear.Poly) (a₁ : ℤ) (x₁ : Int.Linear.Var) (p₁_2 : Int.Linear.Poly) (a₂ : ℤ)
(x₂ : Int.Linear.Var) (p₂_2 : Int.Linear.Poly),
Int.Linear.dvd_solve_elim_cert d₁ (Int.Linear.Poly.add a₁ x₁ p₁_2) d₂ (Int.Linear.Poly.add a₂ x₂ p₂_2) d p =
(Nat.beq x₁ x₂ && (d.beq' ↑((a₁ * d₂).gcd (a₂ * d₁)) && p.beq' (Int.Linear.Poly.combine_mul_k a₂ (-a₁) p₁_2 p₂_2))) |
continuous_sInf_dom₂ | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u_5} {Y : Type u_6} {Z : Type u_7} {f : X → Y → Z} {tas : Set (TopologicalSpace X)}
{tbs : Set (TopologicalSpace Y)} {tX : TopologicalSpace X} {tY : TopologicalSpace Y} {tc : TopologicalSpace Z},
tX ∈ tas → tY ∈ tbs → (Continuous fun p => f p.1 p.2) → Continuous fun p => f p.1 p.2 |
Aesop.Goal.safeRapps | Aesop.Tree.Data | Aesop.Goal → BaseIO (Array Aesop.RappRef) |
Option.or_of_isNone | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o o' : Option α}, o.isNone = true → o.or o' = o' |
Lean.Elab.Tactic.GuardMsgs.MessageOrdering.exact.sizeOf_spec | Lean.Elab.GuardMsgs | sizeOf Lean.Elab.Tactic.GuardMsgs.MessageOrdering.exact = 1 |
CategoryTheory.CommGrpObj.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
{X : C} →
(one : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ X) →
(mul : CategoryTheory.MonoidalCategoryStruct.tensorObj X X ⟶ X) →
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight one X) mul =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom)
CategoryTheory.MonObj.one_mul._autoParam →
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X one) mul =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom)
CategoryTheory.MonObj.mul_one._autoParam →
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight mul X)
mul =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X X X).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X mul)
mul))
CategoryTheory.MonObj.mul_assoc._autoParam →
(inv : X ⟶ X) →
autoParam
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift inv (CategoryTheory.CategoryStruct.id X))
mul =
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.toUnit X)
one)
CategoryTheory.GrpObj.left_inv._autoParam →
autoParam
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.CategoryStruct.id X) inv)
mul =
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.toUnit X)
one)
CategoryTheory.GrpObj.right_inv._autoParam →
autoParam (CategoryTheory.CategoryStruct.comp (β_ X X).hom mul = mul)
CategoryTheory.IsCommMonObj.mul_comm._autoParam →
CategoryTheory.CommGrpObj X |
Lean.Meta.Simp.UsedSimps._sizeOf_inst | Lean.Meta.Tactic.Simp.Types | SizeOf Lean.Meta.Simp.UsedSimps |
Real.sin_arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ (x : ℝ), Real.sin (Real.arccos x) = √(1 - x ^ 2) |
CategoryTheory.Discrete.equivOfEquivalence._proof_1 | Mathlib.CategoryTheory.Discrete.Basic | ∀ {α : Type u_1} {β : Type u_2} (h : CategoryTheory.Discrete α ≌ CategoryTheory.Discrete β) (a : α),
(CategoryTheory.Discrete.as ∘ h.inverse.obj ∘ CategoryTheory.Discrete.mk)
((CategoryTheory.Discrete.as ∘ h.functor.obj ∘ CategoryTheory.Discrete.mk) a) =
a |
ProbabilityTheory.«term_⊗ₖ_» | Mathlib.Probability.Kernel.Composition.CompProd | Lean.TrailingParserDescr |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.isAtoms.go.match_1 | Lean.Elab.DocString.Builtin.Keywords | (motive : List Lean.Syntax → Sort u_1) →
(stxs : List Lean.Syntax) →
(Unit → motive []) →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(val : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) →
(tail : List Lean.Syntax) → motive (Lean.Syntax.ident info rawVal val preresolved :: tail)) →
((info : Lean.SourceInfo) → (s : String) → (ss : List Lean.Syntax) → motive (Lean.Syntax.atom info s :: ss)) →
((ss : List Lean.Syntax) → motive (Lean.Syntax.missing :: ss)) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) →
(args : Array Lean.Syntax) →
(ss : List Lean.Syntax) → motive (Lean.Syntax.node info kind args :: ss)) →
motive stxs |
NumberField.IsCMField.complexConj._proof_1 | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [Algebra.IsIntegral ℚ K], Nonempty (K →+* ℂ) |
AddSubgroup.pi_mem_of_single_mem | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {η : Type u_3} {f : η → Type u_4} [inst : (i : η) → AddGroup (f i)] [Finite η] [inst_2 : DecidableEq η]
{H : AddSubgroup ((i : η) → f i)} (x : (i : η) → f i), (∀ (i : η), Pi.single i (x i) ∈ H) → x ∈ H |
AbsoluteValue.uniformSpace._proof_1 | Mathlib.Topology.UniformSpace.AbsoluteValue | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] {R : Type u_2} [inst_2 : CommRing R]
(abv : AbsoluteValue R 𝕜) (x : R), (fun x y => abv (y - x)) x x = 0 |
Cardinal.toENat_eq_zero | Mathlib.SetTheory.Cardinal.ENat | ∀ {c : Cardinal.{u}}, Cardinal.toENat c = 0 ↔ c = 0 |
NonemptyInterval.instNSMul.eq_1 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : AddMonoid α] [inst_1 : Preorder α] [inst_2 : AddLeftMono α] [inst_3 : AddRightMono α],
NonemptyInterval.instNSMul = { smul := fun x x_1 => { toProd := x • x_1.toProd, fst_le_snd := ⋯ } } |
_private.Mathlib.Topology.Order.IntermediateValue.0.setOf_isPreconnected_eq_of_ordered._simp_1_5 | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) |
CategoryTheory.Functor.mapSkeleton_injective | Mathlib.CategoryTheory.Skeletal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [F.Full] [F.Faithful], Function.Injective F.mapSkeleton.obj |
Lean.Lsp.SymbolTag | Lean.Data.Lsp.LanguageFeatures | Type |
Prod.instSemilatticeInf | Mathlib.Order.Lattice | (α : Type u) → (β : Type v) → [SemilatticeInf α] → [SemilatticeInf β] → SemilatticeInf (α × β) |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real.0.RealRMK.exists_open_approx._simp_1_1 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [MeasureTheory.OuterMeasureClass F α] {μ : F}
{s t : Set α}, s ⊆ t → (μ s ≤ μ t) = True |
CategoryTheory.JointlyReflectIsomorphisms.mk | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {I : Type u_2} {D : I → Type u_3}
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] {F : (i : I) → CategoryTheory.Functor C (D i)},
(∀ {X Y : C} (f : X ⟶ Y) [∀ (i : I), CategoryTheory.IsIso ((F i).map f)], CategoryTheory.IsIso f) →
CategoryTheory.JointlyReflectIsomorphisms F |
Lean.Grind.Fin.pow_zero | Init.GrindInstances.Ring.Fin | ∀ {n : ℕ} [inst : NeZero n] (a : Fin n), a ^ 0 = 1 |
Lean.Lsp.RpcOptions.mk._flat_ctor | Lean.Data.Lsp.Extra | Option Lean.Lsp.HighlightMatchesOptions → Lean.Lsp.RpcOptions |
CategoryTheory.sheafOver_obj | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} A]
{J : CategoryTheory.GrothendieckTopology C} (ℱ : CategoryTheory.Sheaf J A) (E : A),
(CategoryTheory.sheafOver ℱ E).obj = ℱ.obj.comp (CategoryTheory.coyoneda.obj (Opposite.op E)) |
CategoryTheory.Bimon.instBimonObjXXMon._proof_12 | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M : CategoryTheory.Bimon C),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one CategoryTheory.ComonObj.counit.hom =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) |
Lean.Elab.Command.Structure.StructParentInfo.recOn | Lean.Elab.Structure | {motive : Lean.Elab.Command.Structure.StructParentInfo → Sort u} →
(t : Lean.Elab.Command.Structure.StructParentInfo) →
((ref : Lean.Syntax) →
(addTermInfo : Bool) →
(fvar : Lean.Expr) →
(structName name declName : Lean.Name) →
(subobject : Bool) →
motive
{ ref := ref, addTermInfo := addTermInfo, fvar := fvar, structName := structName, name := name,
declName := declName, subobject := subobject }) →
motive t |
LinearPMap.IsClosable.existsUnique | Mathlib.Topology.Algebra.Module.LinearPMap | ∀ {R : Type u_1} {E : Type u_2} {F : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup E] [inst_2 : AddCommGroup F]
[inst_3 : Module R E] [inst_4 : Module R F] [inst_5 : TopologicalSpace E] [inst_6 : TopologicalSpace F]
[inst_7 : ContinuousAdd E] [inst_8 : ContinuousAdd F] [inst_9 : TopologicalSpace R] [inst_10 : ContinuousSMul R E]
[inst_11 : ContinuousSMul R F] {f : E →ₗ.[R] F}, f.IsClosable → ∃! f', f.graph.topologicalClosure = f'.graph |
_private.Mathlib.Logic.Embedding.Set.0.subtypeOrEquiv._proof_1 | Mathlib.Logic.Embedding.Set | ∀ {α : Type u_1} (p q : α → Prop) (x : α), p x → p x ∨ q x |
Std.Sat.AIG.mkGate_decl_eq._proof_2 | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (idx : ℕ) (aig : Std.Sat.AIG α) (input : aig.BinaryInput)
{h : idx < aig.decls.size},
aig.decls.size ≤ (aig.mkGate input).aig.decls.size → idx < (aig.mkGate input).aig.decls.size |
Polynomial.IsEisensteinAt.mem | Mathlib.RingTheory.Polynomial.Eisenstein.Basic | ∀ {R : Type u} [inst : CommSemiring R] {f : Polynomial R} {𝓟 : Ideal R},
f.IsEisensteinAt 𝓟 → ∀ {n : ℕ}, n < f.natDegree → f.coeff n ∈ 𝓟 |
_private.Init.Data.Vector.Lemmas.0.Vector.any_iff_exists._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α} {start stop : ℕ},
(as.any p start stop = true) = ∃ i, ∃ (x : i < as.size), start ≤ i ∧ i < stop ∧ p as[i] = true |
_private.Mathlib.Probability.Kernel.Proper.0.ProbabilityTheory.Kernel.IsProper.lintegral_indicator_mul_indicator._simp_1_2 | Mathlib.Probability.Kernel.Proper | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True |
CategoryTheory.LiftRightAdjoint.otherMap | Mathlib.CategoryTheory.Adjunction.Lifting.Right | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{U : CategoryTheory.Functor A B} →
{F : CategoryTheory.Functor B A} →
(L : CategoryTheory.Functor C B) →
(U' : CategoryTheory.Functor A C) →
(F ⊣ U) → (L.comp F ⊣ U') → (X : B) → U'.obj (F.obj X) ⟶ U'.obj (F.obj (U.obj (F.obj X))) |
Std.DTreeMap.Internal.Impl.getKey?_union! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF → m₂.WF → ∀ {k : α}, (m₁.union! m₂).getKey? k = (m₂.getKey? k).or (m₁.getKey? k) |
Lean.SimplePersistentEnvExtensionDescr.noConfusionType | Lean.EnvExtension | Sort u →
{α σ : Type} →
Lean.SimplePersistentEnvExtensionDescr α σ → {α' σ' : Type} → Lean.SimplePersistentEnvExtensionDescr α' σ' → Sort u |
ContinuousLinearEquiv.automorphismGroup._proof_10 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_1} [inst : Semiring R₁] (M₁ : Type u_2) [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] (f : M₁ ≃L[R₁] M₁), f * 1 = f * 1 |
RingNorm | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | (R : Type u_2) → [NonUnitalNonAssocRing R] → Type u_2 |
TwoSidedIdeal.coeAddMonoidHom._proof_2 | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R) (x x_1 : ↥I), ↑(x + x_1) = ↑(x + x_1) |
ContextFreeGrammar.Derives | Mathlib.Computability.ContextFreeGrammar | {T : Type u_1} → (g : ContextFreeGrammar T) → List (Symbol T g.NT) → List (Symbol T g.NT) → Prop |
mkFactorOrderIsoOfFactorDvdEquiv_apply_coe | Mathlib.RingTheory.ChainOfDivisors | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : IsCancelMulZero M] {N : Type u_2}
[inst_2 : CommMonoidWithZero N] [inst_3 : Subsingleton Mˣ] [inst_4 : Subsingleton Nˣ] [inst_5 : IsCancelMulZero N]
{m : M} {n : N} {d : { l // l ∣ m } ≃ { l // l ∣ n }} (hd : ∀ (l l' : { l // l ∣ m }), ↑(d l) ∣ ↑(d l') ↔ ↑l ∣ ↑l')
(l : ↑(Set.Iic (Associates.mk m))),
↑((mkFactorOrderIsoOfFactorDvdEquiv hd) l) = Associates.mk ↑(d ⟨associatesEquivOfUniqueUnits ↑l, ⋯⟩) |
Nat.sub_add_cancel | Init.Data.Nat.Basic | ∀ {n m : ℕ}, m ≤ n → n - m + m = n |
UInt64.toUSize_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | ∀ {n : ℕ},
UInt64.size ≤ n →
(UInt64.ofNatTruncate n).toUSize = USize.ofNatLT (USize.size - 1) UInt64.toUSize_ofNatTruncate_of_le._proof_1 |
SeminormedAddGroup.noConfusionType | Mathlib.Analysis.Normed.Group.Defs | Sort u → {E : Type u_8} → SeminormedAddGroup E → {E' : Type u_8} → SeminormedAddGroup E' → Sort u |
KaehlerDifferential.D._proof_3 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S], SMulCommClass R S S |
_private.Init.Data.Array.Lemmas.0.Array.back_append._simp_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, (xs = #[]) = (xs.size = 0) |
Lean.Widget.WidgetSource.noConfusionType | Lean.Widget.UserWidget | Sort u → Lean.Widget.WidgetSource → Lean.Widget.WidgetSource → Sort u |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.Internal.List.interSmallerFn.match_1.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_2} {β : α → Type u_1} (motive : Option ((a : α) × β a) → Sort u_3) (kv' : (a : α) × β a)
(h_1 : (kv' : (a : α) × β a) → motive (some kv')) (h_2 : Unit → motive none),
(match some kv' with
| some kv' => h_1 kv'
| none => h_2 ()) =
h_1 kv' |
Lean.Meta.NativeEqTrueResult.casesOn | Lean.Meta.Native | {motive : Lean.Meta.NativeEqTrueResult → Sort u} →
(t : Lean.Meta.NativeEqTrueResult) →
((prf : Lean.Expr) → motive (Lean.Meta.NativeEqTrueResult.success prf)) →
motive Lean.Meta.NativeEqTrueResult.notTrue → motive t |
ProfiniteAddGrp.instHasForget₂FiniteAddGrpAddMonoidHomCarrierToAddGrpContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfinite._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ (X : FiniteAddGrp.{u_1}),
ProfiniteAddGrp.ofFiniteAddGrpHom (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id (ProfiniteAddGrp.ofFiniteAddGrp X) |
_private.Mathlib.Tactic.CongrExclamation.0.Lean.MVarId.congrImplies?'._sparseCasesOn_1 | Mathlib.Tactic.CongrExclamation | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
MeasureTheory.StronglyMeasurable.stronglyMeasurable_in_set | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Zero β] {s : Set α}
{f : α → β},
MeasurableSet s →
MeasureTheory.StronglyMeasurable f →
(∀ x ∉ s, f x = 0) →
∃ fs,
(∀ (x : α), Filter.Tendsto (fun n => (fs n) x) Filter.atTop (nhds (f x))) ∧ ∀ x ∉ s, ∀ (n : ℕ), (fs n) x = 0 |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.cnfSatAssignment.eq_1 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ) (assign1 : ℕ → Bool),
Std.Sat.AIG.toCNF.cnfSatAssignment✝ aig assign1 =
Std.Sat.AIG.toCNF.mixAssigns✝ assign1 fun idx =>
⟦assign1, { aig := aig, ref := { gate := ↑idx, invert := false, hgate := ⋯ } }⟧ |
CategoryTheory.HasSplitCoequalizer.rec | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.HasSplitCoequalizer f g → Sort u_1} →
((splittable : ∃ Z h, Nonempty (CategoryTheory.IsSplitCoequalizer f g h)) → motive ⋯) →
(t : CategoryTheory.HasSplitCoequalizer f g) → motive t |
SemiNormedGrp.instConcreteCategoryNormedAddGroupHomCarrier._proof_3 | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {X : SemiNormedGrp} (x : X.carrier), (CategoryTheory.CategoryStruct.id X).hom' x = x |
_private.Mathlib.Data.Finsupp.Single.0.Finsupp.erase_single_ne._proof_1_1 | Mathlib.Data.Finsupp.Single | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] {a a' : α} {b : M},
a ≠ a' → (Finsupp.erase a fun₀ | a' => b) = fun₀ | a' => b |
LinearMap.BilinForm.isNonneg_def | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : LE R]
{B : LinearMap.BilinForm R M}, B.IsNonneg ↔ ∀ (x : M), 0 ≤ (B x) x |
MeasureTheory.ProbabilityMeasure.toWeakDualBCNN | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | {Ω : Type u_1} →
[inst : MeasurableSpace Ω] →
[inst_1 : TopologicalSpace Ω] →
[OpensMeasurableSpace Ω] →
MeasureTheory.ProbabilityMeasure Ω → WeakDual NNReal (BoundedContinuousFunction Ω NNReal) |
_private.Lean.Elab.Declaration.0.Lean.Elab.Command.expandDeclNamespace?._sparseCasesOn_5 | Lean.Elab.Declaration | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Submodule.quotientRel | Mathlib.LinearAlgebra.Quotient.Defs | {R : Type u_1} →
{M : Type u_2} → [inst : Ring R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Submodule R M → Setoid M |
CategoryTheory.GrothendieckTopology.sheafifyCompIso.congr_simp | Mathlib.CategoryTheory.Sites.CompatibleSheafification | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} E]
(F : CategoryTheory.Functor D E)
[inst_3 :
∀ (J : CategoryTheory.Limits.MulticospanShape),
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WalkingMulticospan J) D]
[inst_4 :
∀ (J : CategoryTheory.Limits.MulticospanShape),
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WalkingMulticospan J) E]
[inst_5 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ D]
[inst_6 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ E]
[inst_7 : ∀ (X : C), CategoryTheory.Limits.PreservesColimitsOfShape (J.Cover X)ᵒᵖ F]
[inst_8 :
∀ (X : C) (W : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D),
CategoryTheory.Limits.PreservesLimit (W.index P).multicospan F]
(P : CategoryTheory.Functor Cᵒᵖ D), J.sheafifyCompIso F P = J.sheafifyCompIso F P |
ZeroHom.smul_apply | Mathlib.Algebra.GroupWithZero.Action.Hom | ∀ {M : Type u_1} {A : Type u_3} {B : Type u_4} [inst : Zero A] [inst_1 : Zero B] [inst_2 : SMulZeroClass M B] (m : M)
(f : ZeroHom A B) (a : A), (m • f) a = m • f a |
DirectLimit.map._proof_1 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_3} [inst : Preorder ι] {F₁ : ι → Type u_5} {F₂ : ι → Type u_1} {T₁ : ⦃i j : ι⦄ → i ≤ j → Sort u_4}
(f₁ : (i j : ι) → (h : i ≤ j) → T₁ h) [inst_1 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T₁ h) (F₁ i) (F₁ j)]
[DirectedSystem F₁ fun x1 x2 x3 => ⇑(f₁ x1 x2 x3)] {T₂ : ⦃i j : ι⦄ → i ≤ j → Sort u_2}
(f₂ : (i j : ι) → (h : i ≤ j) → T₂ h) [inst_3 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T₂ h) (F₂ i) (F₂ j)]
(ih : (i : ι) → F₁ i → F₂ i),
(∀ (i j : ι) (h : i ≤ j) (x : F₁ i), (f₂ i j h) (ih i x) = ih j ((f₁ i j h) x)) →
∀ (j k : ι) (h : j ≤ k) (x : F₁ j) (i : ι) (hji : j ≤ i) (hki : k ≤ i),
(f₂ ⟨j, ih j x⟩.fst i hji) ⟨j, ih j x⟩.snd = (f₂ ⟨k, ih k ((f₁ j k h) x)⟩.fst i hki) ⟨k, ih k ((f₁ j k h) x)⟩.snd |
CategoryTheory.IsIso.comp_inv_eq._simp_1 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : Y ⟶ X) [inst_1 : CategoryTheory.IsIso α]
{f : Z ⟶ X} {g : Z ⟶ Y},
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) = g) = (f = CategoryTheory.CategoryStruct.comp g α) |
Algebra.mem_sup_left | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {S T : Subalgebra R A}
{x : A}, x ∈ S → x ∈ S ⊔ T |
Bundle.ContMDiffRiemannianMetric.toContinuousRiemannianMetric | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | {EB : Type u_1} →
[inst : NormedAddCommGroup EB] →
[inst_1 : NormedSpace ℝ EB] →
{HB : Type u_2} →
[inst_2 : TopologicalSpace HB] →
{IB : ModelWithCorners ℝ EB HB} →
{n : WithTop ℕ∞} →
{B : Type u_3} →
[inst_3 : TopologicalSpace B] →
[inst_4 : ChartedSpace HB B] →
{F : Type u_4} →
[inst_5 : NormedAddCommGroup F] →
[inst_6 : NormedSpace ℝ F] →
{E : B → Type u_5} →
[inst_7 : TopologicalSpace (Bundle.TotalSpace F E)] →
[inst_8 : (b : B) → TopologicalSpace (E b)] →
[inst_9 : (b : B) → AddCommGroup (E b)] →
[inst_10 : (b : B) → Module ℝ (E b)] →
[inst_11 : FiberBundle F E] →
[inst_12 : VectorBundle ℝ F E] →
Bundle.ContMDiffRiemannianMetric IB n F E →
Bundle.ContinuousRiemannianMetric F E |
Aesop.Match.mk.sizeOf_spec | Aesop.Forward.Match.Types | ∀ (subst : Aesop.Substitution) (patInstSubsts : Array Aesop.Substitution) (level : Aesop.SlotIndex)
(forwardDeps conclusionDeps : Array Aesop.PremiseIndex),
sizeOf
{ subst := subst, patInstSubsts := patInstSubsts, level := level, forwardDeps := forwardDeps,
conclusionDeps := conclusionDeps } =
1 + sizeOf subst + sizeOf patInstSubsts + sizeOf level + sizeOf forwardDeps + sizeOf conclusionDeps |
Std.Tactic.BVDecide.instDecidableEqBVBinOp._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (x y : Std.Tactic.BVDecide.BVBinOp), ¬x.ctorIdx = y.ctorIdx → x = y → False |
Rack.PreEnvelGroupRel'.act_incl.elim | Mathlib.Algebra.Quandle | {R : Type u} →
[inst : Rack R] →
{motive : (a a_1 : Rack.PreEnvelGroup R) → Rack.PreEnvelGroupRel' R a a_1 → Sort u_1} →
{a a_1 : Rack.PreEnvelGroup R} →
(t : Rack.PreEnvelGroupRel' R a a_1) →
t.ctorIdx = 9 →
((x y : R) →
motive
(((Rack.PreEnvelGroup.incl x).mul (Rack.PreEnvelGroup.incl y)).mul (Rack.PreEnvelGroup.incl x).inv)
(Rack.PreEnvelGroup.incl (Shelf.act x y)) (Rack.PreEnvelGroupRel'.act_incl x y)) →
motive a a_1 t |
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.TaggedTextHighlightState.mk.noConfusion | Lean.Server.FileWorker.WidgetRequests | {P : Sort u} →
{query : String} →
{ms : Array String.Pos.Raw} →
{p : String.Pos.Raw} →
{anyHighlight : Bool} →
{query' : String} →
{ms' : Array String.Pos.Raw} →
{p' : String.Pos.Raw} →
{anyHighlight' : Bool} →
{ query := query, ms := ms, p := p, anyHighlight := anyHighlight } =
{ query := query', ms := ms', p := p', anyHighlight := anyHighlight' } →
(query = query' → ms = ms' → p = p' → anyHighlight = anyHighlight' → P) → P |
IsLocalization.AtPrime.mem_primesOver_of_isPrime | Mathlib.RingTheory.Localization.AtPrime.Extension | ∀ (Rₚ : Type u_3) [inst : CommRing Rₚ] [inst_1 : IsLocalRing Rₚ] (Sₚ : Type u_4) [inst_2 : CommRing Sₚ]
[inst_3 : Algebra Rₚ Sₚ] {Q : Ideal Sₚ} [Q.IsMaximal] [Algebra.IsIntegral Rₚ Sₚ],
Q ∈ (IsLocalRing.maximalIdeal Rₚ).primesOver Sₚ |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_diff_iff._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
CategoryTheory.Functor.descColimitType_comp_ι | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J (Type w₀)) (c : F.CoconeTypes)
(j : J), F.descColimitType c ∘ F.ιColimitType j = c.ι j |
Lean.Elab.Term.BodyInfo.casesOn | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.BodyInfo → Sort u} →
(t : Lean.Elab.Term.BodyInfo) → ((value? : Option Lean.Expr) → motive { value? := value? }) → motive t |
Matrix.conjTransposeAddEquiv_symm | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ (m : Type u_2) (n : Type u_3) (α : Type v) [inst : AddMonoid α] [inst_1 : StarAddMonoid α],
(Matrix.conjTransposeAddEquiv m n α).symm = Matrix.conjTransposeAddEquiv n m α |
MeasureTheory.hasFiniteIntegral_iff_enorm | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {ε : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε] {f : α → ε},
MeasureTheory.HasFiniteIntegral f μ ↔ ∫⁻ (a : α), ‖f a‖ₑ ∂μ < ⊤ |
_private.Aesop.RuleSet.Member.0.Aesop.LocalRuleSetMember.name.match_1 | Aesop.RuleSet.Member | (motive : Aesop.LocalRuleSetMember → Sort u_1) →
(x : Aesop.LocalRuleSetMember) →
((m : Aesop.GlobalRuleSetMember) → motive (Aesop.LocalRuleSetMember.global m)) →
((r : Aesop.LocalNormSimpRule) → motive (Aesop.LocalRuleSetMember.localNormSimpRule r)) → motive x |
Lean.Sym.UInt16.lt_eq_false | Init.Sym.Lemmas | ∀ (a b : UInt16), decide (a < b) = false → (a < b) = False |
HasQuotient.quotient' | Mathlib.Algebra.Quotient | {A : outParam (Type u)} → {B : Type v} → [HasQuotient A B] → B → Type (max u v) |
IsLocalization.mapFrameHom._proof_1 | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_2} [inst : CommSemiring R] (S : Type u_1) [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
Ideal.map (algebraMap R S) ⊤ = ⊤ |
CategoryTheory.Abelian.SpectralObject.opcyclesMap_fromOpcycles | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) {i' j' k' : ι} (f' : i' ⟶ j')
(g' : j' ⟶ k') (fg : i ⟶ k) (h : CategoryTheory.CategoryStruct.comp f g = fg) (fg' : i' ⟶ k')
(h' : CategoryTheory.CategoryStruct.comp f' g' = fg')
(α : CategoryTheory.ComposableArrows.mk₂ f g ⟶ CategoryTheory.ComposableArrows.mk₂ f' g')
(β : CategoryTheory.ComposableArrows.mk₁ fg ⟶ CategoryTheory.ComposableArrows.mk₁ fg') (n : ℤ),
autoParam (β.app 0 = α.app 0) CategoryTheory.Abelian.SpectralObject.opcyclesMap_fromOpcycles._auto_1 →
autoParam (β.app 1 = α.app 2) CategoryTheory.Abelian.SpectralObject.opcyclesMap_fromOpcycles._auto_3 →
CategoryTheory.CategoryStruct.comp (X.opcyclesMap f g f' g' α n) (X.fromOpcycles f' g' fg' h' n) =
CategoryTheory.CategoryStruct.comp (X.fromOpcycles f g fg h n) ((X.H n).map β) |
AlgebraicGeometry.Scheme.isPullback_of_openCover | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z W : AlgebraicGeometry.Scheme} (fWX : W ⟶ X) (fWY : W ⟶ Y) (fXZ : X ⟶ Z) (fYZ : Y ⟶ Z) (𝒰 : X.OpenCover),
(∀ (i : 𝒰.toPreZeroHypercover.1),
CategoryTheory.IsPullback (AlgebraicGeometry.Scheme.Cover.pullbackHom 𝒰 fWX i)
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ fWX 𝒰).f i) fWY)
(CategoryTheory.CategoryStruct.comp (𝒰.f i) fXZ) fYZ) →
CategoryTheory.IsPullback fWX fWY fXZ fYZ |
TopologicalSpace.Compacts.instOrderBot._proof_2 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α], ↑⊥ = ↑⊥ |
_private.Mathlib.Tactic.Widget.InteractiveUnfold.0.Mathlib.Tactic.InteractiveUnfold.UnfoldComponent._proof_1 | Mathlib.Tactic.Widget.InteractiveUnfold | hash
"window;import{jsxs as e,jsx as t,Fragment as n}from\"react/jsx-runtime\";import*as r from\"react\";import{useRpcSession as a,EnvPosContext as o,useAsyncPersistent as c,mapRpcError as s,importWidgetModule as i}from\"@leanprover/infoview\";async function l(a,o,c){if(\"text\"in c)return t(n,{children:c.text});if(\"element\"in c){const[e,n,s]=c.element,i={};for(const[e,t]of n)i[e]=t;const u=await Promise.all(s.map((async e=>await l(a,o,e))));return\"hr\"===e?t(\"hr\",{}):0===u.length?r.createElement(e,i):r.createElement(e,i,u)}if(\"component\"in c){const[e,t,n,s]=c.component,u=await Promise.all(s.map((async e=>await l(a,o,e)))),m={...n,pos:o},f=await i(a,o,e);if(!(t in f))throw new Error(`Module '${e}' does not export '${t}'`);return 0===u.length?r.createElement(f[t],m):r.createElement(f[t],m,u)}return e(\"span\",{className:\"red\",children:[\"Unknown HTML variant: \",JSON.stringify(c)]})}function u({html:i}){const u=a(),m=r.useContext(o),f=c((()=>l(u,m,i)),[u,m,i]);return\"resolved\"===f.state?f.value:\"rejected\"===f.state?e(\"span\",{className:\"red\",children:[\"Error rendering HTML: \",s(f.error).message]}):t(n,{})}const m=\"Mathlib.Tactic.InteractiveUnfold.rpc\",f='false';var d=r.memo((e=>{const o=a(),i=r.useRef({fn:()=>{}}),l=c((async()=>{if(\"true\"===f){i.current.fn();const[t,n]=function(e,t,n){const r={fn:()=>{}};return[new Promise((async(a,o)=>{const c=await e.call(t,n),s=window.setInterval((async()=>{try{const t=await e.call(\"ProofWidgets.checkRequest\",c);if(\"running\"===t)return;window.clearInterval(s),a(t.done.result)}catch(e){window.clearInterval(s),o(e)}}),100);r.fn=()=>{e.call(\"ProofWidgets.cancelRequest\",c)}})),r]}(o,m,e);return i.current=n,t}return o.call(m,e)}),[o,e]);return r.useEffect((()=>()=>{i.current.fn()}),[]),\"rejected\"===l.state?t(\"p\",{style:{color:\"red\"},children:s(l.error).message}):\"loading\"===l.state?t(n,{children:\"Loading..\"}):t(u,{html:l.value})}));export{d as default};" =
hash
"window;import{jsxs as e,jsx as t,Fragment as n}from\"react/jsx-runtime\";import*as r from\"react\";import{useRpcSession as a,EnvPosContext as o,useAsyncPersistent as c,mapRpcError as s,importWidgetModule as i}from\"@leanprover/infoview\";async function l(a,o,c){if(\"text\"in c)return t(n,{children:c.text});if(\"element\"in c){const[e,n,s]=c.element,i={};for(const[e,t]of n)i[e]=t;const u=await Promise.all(s.map((async e=>await l(a,o,e))));return\"hr\"===e?t(\"hr\",{}):0===u.length?r.createElement(e,i):r.createElement(e,i,u)}if(\"component\"in c){const[e,t,n,s]=c.component,u=await Promise.all(s.map((async e=>await l(a,o,e)))),m={...n,pos:o},f=await i(a,o,e);if(!(t in f))throw new Error(`Module '${e}' does not export '${t}'`);return 0===u.length?r.createElement(f[t],m):r.createElement(f[t],m,u)}return e(\"span\",{className:\"red\",children:[\"Unknown HTML variant: \",JSON.stringify(c)]})}function u({html:i}){const u=a(),m=r.useContext(o),f=c((()=>l(u,m,i)),[u,m,i]);return\"resolved\"===f.state?f.value:\"rejected\"===f.state?e(\"span\",{className:\"red\",children:[\"Error rendering HTML: \",s(f.error).message]}):t(n,{})}const m=\"Mathlib.Tactic.InteractiveUnfold.rpc\",f='false';var d=r.memo((e=>{const o=a(),i=r.useRef({fn:()=>{}}),l=c((async()=>{if(\"true\"===f){i.current.fn();const[t,n]=function(e,t,n){const r={fn:()=>{}};return[new Promise((async(a,o)=>{const c=await e.call(t,n),s=window.setInterval((async()=>{try{const t=await e.call(\"ProofWidgets.checkRequest\",c);if(\"running\"===t)return;window.clearInterval(s),a(t.done.result)}catch(e){window.clearInterval(s),o(e)}}),100);r.fn=()=>{e.call(\"ProofWidgets.cancelRequest\",c)}})),r]}(o,m,e);return i.current=n,t}return o.call(m,e)}),[o,e]);return r.useEffect((()=>()=>{i.current.fn()}),[]),\"rejected\"===l.state?t(\"p\",{style:{color:\"red\"},children:s(l.error).message}):\"loading\"===l.state?t(n,{children:\"Loading..\"}):t(u,{html:l.value})}));export{d as default};" |
CategoryTheory.LocallyDiscrete.rec | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | {C : Type u} →
{motive : CategoryTheory.LocallyDiscrete C → Sort u_1} →
((as : C) → motive { as := as }) → (t : CategoryTheory.LocallyDiscrete C) → motive t |
CategoryTheory.ExponentiableMorphism.mk._flat_ctor | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I J : C} →
{f : I ⟶ J} →
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] →
(pushforward : CategoryTheory.Functor (CategoryTheory.Over I) (CategoryTheory.Over J)) →
(CategoryTheory.ChosenPullbacksAlong.pullback f ⊣ pushforward) → CategoryTheory.ExponentiableMorphism f |
Dense.extend_spec | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β] {s : Set α} {f : ↑s → β}
[CompleteSpace β] (hs : Dense s),
UniformContinuous f → ∀ (a : α), Filter.Tendsto f (Filter.comap Subtype.val (nhds a)) (nhds (hs.extend f a)) |
_private.Mathlib.Data.Int.Fib.Basic.0.Int.fib_two_mul_add_one_pos._proof_1_1 | Mathlib.Data.Int.Fib.Basic | ∀ {n : ℤ}, 0 < Int.fib (2 * n + 1) |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.lipschitzWith_ofLp_aux._simp_1_1 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {a : α},
(s.sup f ≤ a) = ∀ b ∈ s, f b ≤ a |
CategoryTheory.Presieve.shrinkFunctorHomEquiv._proof_2 | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X : C} {S : CategoryTheory.Sieve X}
[inst_1 : CategoryTheory.LocallySmall.{u_1, u_2, u_3} C] (X_1 : Cᵒᵖ)
(f : (CategoryTheory.Sieve.shrinkFunctor.{u_1, u_2, u_3} S).toFunctor.obj X_1),
↑f ∈ (CategoryTheory.Sieve.shrinkFunctor.{u_1, u_2, u_3} S).obj X_1 |
Homotopy.extendEquiv | Mathlib.Algebra.Homology.Embedding.ExtendHomotopy | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Preadditive C] →
{K L : HomologicalComplex C c} →
{f g : K ⟶ L} →
(e : c.Embedding c') →
[e.IsRelIff] →
Homotopy f g ≃ Homotopy (HomologicalComplex.extendMap f e) (HomologicalComplex.extendMap g e) |
Fin.modn_val | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (a : Fin n) (b : ℕ), ↑(a.modn b) = ↑a % b |
Equiv.Perm.IsCycleOn.inv | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {s : Set α}, f.IsCycleOn s → f⁻¹.IsCycleOn s |
Std.DTreeMap.Internal.Impl.minKeyD._unary._proof_2 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : α → Type u_2} (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β) (size_1 : ℕ)
(k_1 : α) (v_1 : β k_1) (l_1 r : Std.DTreeMap.Internal.Impl α β)
(h : l = Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) (r_1 : Std.DTreeMap.Internal.Impl α β) (fallback : α),
(invImage (fun x => PSigma.casesOn x fun a a_1 => a) sizeOfWFRel).1 ⟨l, fallback⟩
⟨Std.DTreeMap.Internal.Impl.inner size k v
(namedPattern l (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) h) r_1,
fallback⟩ |
AlgebraicGeometry.exists_eq_pow_mul_of_isAffineOpen._proof_2 | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ (X : AlgebraicGeometry.Scheme) (U : X.Opens) (f : ↑(X.presheaf.obj (Opposite.op U))), X.basicOpen f ≤ U |
Nat.mod_div_self | Init.Data.Nat.Lemmas | ∀ (m n : ℕ), m % n / n = 0 |
CategoryTheory.GrothendieckTopology.isClosed_iff_close_eq_self | Mathlib.CategoryTheory.Sites.Closed | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J₁ : CategoryTheory.GrothendieckTopology C) {X : C}
(S : CategoryTheory.Sieve X), J₁.IsClosed S ↔ J₁.close S = S |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.