name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
CategoryTheory.ComposableArrows.IsComplex.mk
|
Mathlib.Algebra.Homology.ExactSequence
|
∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S : CategoryTheory.ComposableArrows C n},
(∀ (i : ℕ) (hi : autoParam (i + 2 ≤ n) _auto✝),
CategoryTheory.CategoryStruct.comp (S.map' i (i + 1) ⋯ ⋯) (S.map' (i + 1) (i + 2) ⋯ hi) = 0) →
S.IsComplex
|
_private.Lean.Elab.Tactic.Do.ProofMode.Cases.0.Lean.Elab.Tactic.Do.ProofMode.mCasesExists.match_3
|
Lean.Elab.Tactic.Do.ProofMode.Cases
|
(motive : Lean.Name × Lean.Syntax → Sort u_1) →
(__discr : Lean.Name × Lean.Syntax) → ((name : Lean.Name) → (ref : Lean.Syntax) → motive (name, ref)) → motive __discr
|
ContDiffAt.csin
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
|
∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {n : WithTop ℕ∞},
ContDiffAt ℂ n f x → ContDiffAt ℂ n (fun x => Complex.sin (f x)) x
|
Std.TreeMap.getElem?_eq_some_iff_exists_compare_eq_eq_and_mem_toList
|
Std.Data.TreeMap.Lemmas
|
∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β},
t[k]? = some v ↔ ∃ k', cmp k k' = Ordering.eq ∧ (k', v) ∈ t.toList
|
enorm_add_le
|
Mathlib.Analysis.Normed.Group.Basic
|
∀ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ESeminormedAddMonoid E] (a b : E), ‖a + b‖ₑ ≤ ‖a‖ₑ + ‖b‖ₑ
|
Array.isEmpty_toList
|
Init.Data.Array.Lemmas
|
∀ {α : Type u_1} {xs : Array α}, xs.toList.isEmpty = xs.isEmpty
|
Profinite.NobelingProof.spanCone_isLimit
|
Mathlib.Topology.Category.Profinite.Nobeling.Basic
|
{I : Type u} →
{C : Set (I → Bool)} →
[inst : (s : Finset I) → (i : I) → Decidable (i ∈ s)] →
(hC : IsCompact C) → CategoryTheory.Limits.IsLimit (Profinite.NobelingProof.spanCone hC)
|
AddUnits.instCoeHead
|
Mathlib.Algebra.Group.Units.Defs
|
{α : Type u} → [inst : AddMonoid α] → CoeHead (AddUnits α) α
|
_private.Init.Data.Nat.Lemmas.0.Nat.mul_add_mod.match_1_1
|
Init.Data.Nat.Lemmas
|
∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (x : ℕ), motive x.succ) → motive x
|
NumberField.Units.dirichletUnitTheorem.map_logEmbedding_sup_torsion
|
Mathlib.NumberTheory.NumberField.Units.DirichletTheorem
|
∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (s : AddSubgroup (Additive (NumberField.RingOfIntegers K)ˣ)),
AddSubgroup.map (NumberField.Units.logEmbedding K) (s ⊔ Subgroup.toAddSubgroup (NumberField.Units.torsion K)) =
AddSubgroup.map (NumberField.Units.logEmbedding K) s
|
_private.Mathlib.Order.WithBot.0.WithBot.ofDual_le_iff._simp_1_1
|
Mathlib.Order.WithBot
|
∀ {α : Type u_1} [inst : LE α] {a : α} {b : αᵒᵈ}, (OrderDual.toDual a ≤ b) = (OrderDual.ofDual b ≤ a)
|
PFunctor.Approx.CofixA.recOn
|
Mathlib.Data.PFunctor.Univariate.M
|
{F : PFunctor.{uA, uB}} →
{motive : (a : ℕ) → PFunctor.Approx.CofixA F a → Sort u} →
{a : ℕ} →
(t : PFunctor.Approx.CofixA F a) →
motive 0 PFunctor.Approx.CofixA.continue →
({n : ℕ} →
(a : F.A) →
(a_1 : F.B a → PFunctor.Approx.CofixA F n) →
((a : F.B a) → motive n (a_1 a)) → motive n.succ (PFunctor.Approx.CofixA.intro a a_1)) →
motive a t
|
Std.DTreeMap.Internal.Impl.SizedBalancedTree.toBalancedTree
|
Std.Data.DTreeMap.Internal.Operations
|
{α : Type u} →
{β : α → Type v} →
{lb ub : ℕ} → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β lb ub → Std.DTreeMap.Internal.Impl.BalancedTree α β
|
_private.Lean.Server.Watchdog.0.Lean.Server.Watchdog.forwardMessages
|
Lean.Server.Watchdog
|
Lean.Server.Watchdog.FileWorker → Lean.Server.Watchdog.ServerM (Lean.Server.ServerTask Lean.Server.Watchdog.WorkerEvent)
|
IntermediateField.sup_toSubalgebra_of_isAlgebraic_left
|
Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra
|
∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
(E1 E2 : IntermediateField K L) [Algebra.IsAlgebraic K ↥E1],
(E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra
|
Rat.commRing._proof_4
|
Mathlib.Algebra.Ring.Rat
|
↑↑0 = ↑↑0
|
derivWithin_pow
|
Mathlib.Analysis.Calculus.Deriv.Pow
|
∀ {𝕜 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedCommRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {f : 𝕜 → 𝔸} {x : 𝕜} {s : Set 𝕜},
DifferentiableWithinAt 𝕜 f s x → ∀ (n : ℕ), derivWithin (f ^ n) s x = ↑n * f x ^ (n - 1) * derivWithin f s x
|
Char.card_pow_card
|
Mathlib.NumberTheory.GaussSum
|
∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {F' : Type u_2} [inst_2 : Field F'] [inst_3 : Fintype F']
{χ : MulChar F F'},
χ ≠ 1 →
χ.IsQuadratic →
ringChar F' ≠ ringChar F →
ringChar F' ≠ 2 → (χ (-1) * ↑(Fintype.card F)) ^ (Fintype.card F' / 2) = χ ↑(Fintype.card F')
|
_auto._@.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.2009537970._hygCtx._hyg.73
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital
|
Lean.Syntax
|
BitVec.getElem_neg
|
Init.Data.BitVec.Bitblast
|
∀ {w i : ℕ} {x : BitVec w} (h : i < w), (-x)[i] = (x[i] ^^ decide (∃ j < i, x.getLsbD j = true))
|
Lean.Elab.addPreDefInfo
|
Lean.Elab.PreDefinition.Basic
|
Lean.Elab.PreDefinition → Lean.Elab.TermElabM Unit
|
HahnSeries.map.congr_simp
|
Mathlib.RingTheory.HahnSeries.Basic
|
∀ {Γ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero S]
(x x_1 : HahnSeries Γ R),
x = x_1 →
∀ {F : Type u_5} [inst_3 : FunLike F R S] [inst_4 : ZeroHomClass F R S] (f f_1 : F), f = f_1 → x.map f = x_1.map f_1
|
_private.Mathlib.Probability.Independence.Integration.0.ProbabilityTheory.lintegral_mul_indicator_eq_lintegral_mul_lintegral_indicator._simp_1_2
|
Mathlib.Probability.Independence.Integration
|
∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True
|
Int32.ofNat_add
|
Init.Data.SInt.Lemmas
|
∀ (a b : ℕ), Int32.ofNat (a + b) = Int32.ofNat a + Int32.ofNat b
|
_private.Mathlib.CategoryTheory.Monoidal.Cartesian.Basic.0.CategoryTheory.CartesianMonoidalCategory.associator_hom_snd_fst._simp_1_1
|
Mathlib.CategoryTheory.Monoidal.Cartesian.Basic
|
∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] (X Y : C) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X Y (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).hom
h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).hom) h
|
Sat.Literal.noConfusion
|
Mathlib.Tactic.Sat.FromLRAT
|
{P : Sort u} → {x1 x2 : Sat.Literal} → x1 = x2 → Sat.Literal.noConfusionType P x1 x2
|
MonoidWithZeroHom.instGroupWithZeroSubtypeMemSubmonoidMrange
|
Mathlib.Algebra.GroupWithZero.Submonoid.Instances
|
{G : Type u_1} →
{H : Type u_2} →
[inst : GroupWithZero G] → [inst_1 : GroupWithZero H] → (f : G →*₀ H) → GroupWithZero ↥(MonoidHom.mrange f)
|
Lean.Elab.Tactic.evalExposeNames
|
Lean.Elab.Tactic.ExposeNames
|
Lean.Elab.Tactic.Tactic
|
Lean.TagDeclarationExtension
|
Lean.EnvExtension
|
Type
|
openSegment_subset_segment
|
Mathlib.Analysis.Convex.Segment
|
∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (x y : E), openSegment 𝕜 x y ⊆ segment 𝕜 x y
|
Lean.Compiler.LCNF.Phase.toNat
|
Lean.Compiler.LCNF.PassManager
|
Lean.Compiler.LCNF.Phase → ℕ
|
Units.isOpenEmbedding_val
|
Mathlib.Analysis.Normed.Ring.Units
|
∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R], Topology.IsOpenEmbedding Units.val
|
AlgebraicGeometry.Scheme.instIsOverMapStalkSpecializesCommRingCatPresheaf
|
Mathlib.AlgebraicGeometry.Stalk
|
∀ {X : AlgebraicGeometry.Scheme} {x y : ↥X} (h : x ⤳ y),
AlgebraicGeometry.Scheme.Hom.IsOver (AlgebraicGeometry.Spec.map (X.presheaf.stalkSpecializes h)) X
|
Algebra.Extension.infinitesimal.eq_1
|
Mathlib.RingTheory.Smooth.Kaehler
|
∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Extension R S),
P.infinitesimal =
{ Ring := P.Ring ⧸ P.ker ^ 2, commRing := Ideal.Quotient.commRing (P.ker ^ 2),
algebra₁ := Ideal.instAlgebraQuotient R (P.ker ^ 2), algebra₂ := Ideal.Algebra.kerSquareLift, isScalarTower := ⋯,
σ := ⇑(Ideal.Quotient.mk (P.ker ^ 2)) ∘ P.σ, algebraMap_σ := ⋯ }
|
HSpaces._aux_Mathlib_Topology_Homotopy_HSpaces___unexpand_HSpace_hmul_1
|
Mathlib.Topology.Homotopy.HSpaces
|
Lean.PrettyPrinter.Unexpander
|
List.getRest._sunfold
|
Batteries.Data.List.Basic
|
{α : Type u_1} → [DecidableEq α] → List α → List α → Option (List α)
|
Aesop.BaseM.instMonadHashMapCacheAdapterExprRPINFRaw
|
Aesop.BaseM
|
Lean.MonadHashMapCacheAdapter Lean.Expr Aesop.RPINFRaw Aesop.BaseM
|
PredOrder.pred
|
Mathlib.Order.SuccPred.Basic
|
{α : Type u_3} → {inst : Preorder α} → [self : PredOrder α] → α → α
|
Stream'.Seq.mem_cons_of_mem
|
Mathlib.Data.Seq.Defs
|
∀ {α : Type u} (y : α) {a : α} {s : Stream'.Seq α}, a ∈ s → a ∈ Stream'.Seq.cons y s
|
_private.Mathlib.Analysis.FunctionalSpaces.SobolevInequality.0.«_aux_Mathlib_Analysis_FunctionalSpaces_SobolevInequality___macroRules__private_Mathlib_Analysis_FunctionalSpaces_SobolevInequality_0_term#__1»
|
Mathlib.Analysis.FunctionalSpaces.SobolevInequality
|
Lean.Macro
|
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_of_countable._simp_1_5
|
Mathlib.Probability.ProductMeasure
|
∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [MeasureTheory.IsZeroOrProbabilityMeasure μ]
{s : Set α}, (μ s ≤ 1) = True
|
_private.Mathlib.LinearAlgebra.PiTensorProduct.Basis.0.Basis.piTensorProduct_apply._simp_1_1
|
Mathlib.LinearAlgebra.PiTensorProduct.Basis
|
∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (∀ (x : α), f x = g x) = (f = g)
|
Filter.Germ.liftPred_const
|
Mathlib.Order.Filter.Germ.Basic
|
∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {p : β → Prop} {x : β}, p x → Filter.Germ.LiftPred p ↑x
|
SummationFilter.NeBot.ne_bot
|
Mathlib.Topology.Algebra.InfiniteSum.SummationFilter
|
∀ {β : Type u_2} {L : SummationFilter β} [self : L.NeBot], L.filter.NeBot
|
Set.Nonempty.right
|
Mathlib.Data.Set.Basic
|
∀ {α : Type u} {s t : Set α}, (s ∩ t).Nonempty → t.Nonempty
|
Filter.map₂_inf_subset_left
|
Mathlib.Order.Filter.NAry
|
∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f₁ f₂ : Filter α} {g : Filter β},
Filter.map₂ m (f₁ ⊓ f₂) g ≤ Filter.map₂ m f₁ g ⊓ Filter.map₂ m f₂ g
|
StandardEtalePair.lift.eq_1
|
Mathlib.RingTheory.Etale.StandardEtale
|
∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : StandardEtalePair R) (x : S) (h : P.HasMap x),
P.lift x h =
Ideal.Quotient.liftₐ (Ideal.span {Polynomial.C P.f, Polynomial.X * Polynomial.C P.g - 1})
(Polynomial.aevalAeval x ↑⋯.unit⁻¹) ⋯
|
MeasureTheory.Filtration.piFinset
|
Mathlib.Probability.Process.Filtration
|
{ι : Type u_4} →
{X : ι → Type u_5} → [inst : (i : ι) → MeasurableSpace (X i)] → MeasureTheory.Filtration (Finset ι) MeasurableSpace.pi
|
CpltSepUniformSpace.coe_of
|
Mathlib.Topology.Category.UniformSpace
|
∀ (X : Type u) [inst : UniformSpace X] [inst_1 : CompleteSpace X] [inst_2 : T0Space X], (CpltSepUniformSpace.of X).α = X
|
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.instToJsonRpcEncodablePacket.toJson.match_1._@.Lean.Server.FileWorker.WidgetRequests.433376973._hygCtx._hyg.121
|
Lean.Server.FileWorker.WidgetRequests
|
(motive : Lean.Widget.RpcEncodablePacket✝ → Sort u_1) →
(x : Lean.Widget.RpcEncodablePacket✝) →
((a : Lean.Json) → motive (Lean.Widget.RpcEncodablePacket.expr✝ a)) →
((a : Lean.Json) → motive (Lean.Widget.RpcEncodablePacket.goal✝ a)) →
((a a_1 : Lean.Json) → motive (Lean.Widget.RpcEncodablePacket.widget✝ a a_1)) →
((a a_1 a_2 a_3 a_4 : Lean.Json) → motive (Lean.Widget.RpcEncodablePacket.trace✝ a a_1 a_2 a_3 a_4)) →
(Unit → motive Lean.Widget.RpcEncodablePacket.highlighted✝) → motive x
|
Std.DTreeMap.Internal.Impl.empty
|
Std.Data.DTreeMap.Internal.Operations
|
{α : Type u} → {β : α → Type v} → Std.DTreeMap.Internal.Impl α β
|
ContinuousMapZero.nonUnitalStarAlgHom_precomp
|
Mathlib.Topology.ContinuousMap.ContinuousMapZero
|
{X : Type u_1} →
{Y : Type u_2} →
(R : Type u_4) →
[inst : Zero X] →
[inst_1 : Zero Y] →
[inst_2 : TopologicalSpace X] →
[inst_3 : TopologicalSpace Y] →
[inst_4 : TopologicalSpace R] →
[inst_5 : CommSemiring R] →
[inst_6 : StarRing R] →
[inst_7 : IsTopologicalSemiring R] →
[inst_8 : ContinuousStar R] →
ContinuousMapZero X Y → ContinuousMapZero Y R →⋆ₙₐ[R] ContinuousMapZero X R
|
_private.Mathlib.SetTheory.Cardinal.NatCount.0.Nat.count_le_setENCard._simp_1_1
|
Mathlib.SetTheory.Cardinal.NatCount
|
∀ {n : ℕ} {c : Cardinal.{u_3}}, (↑n ≤ Cardinal.toENat c) = (↑n ≤ c)
|
CategoryTheory.ObjectProperty.limitsClosure.below.of_mem
|
Mathlib.CategoryTheory.ObjectProperty.LimitsClosure
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)]
{motive : (a : C) → P.limitsClosure J a → Prop} (X : C) (hX : P X),
CategoryTheory.ObjectProperty.limitsClosure.below ⋯
|
Set.Icc_top
|
Mathlib.Order.Interval.Set.Basic
|
∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] {a : α}, Set.Icc a ⊤ = Set.Ici a
|
RatFunc._sizeOf_inst
|
Mathlib.FieldTheory.RatFunc.Defs
|
(K : Type u) → {inst : CommRing K} → [SizeOf K] → SizeOf (RatFunc K)
|
Lean.Doc.PostponedName.mk.noConfusion
|
Lean.Elab.DocString.Builtin.Postponed
|
(P : Sort u) → (name name' : Lean.Name) → { name := name } = { name := name' } → (name = name' → P) → P
|
RingCat.instConcreteCategoryRingHomCarrier._proof_4
|
Mathlib.Algebra.Category.Ring.Basic
|
∀ {X Y Z : RingCat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X),
(CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x)
|
Finset.iSup_singleton
|
Mathlib.Order.CompleteLattice.Finset
|
∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] (a : α) (s : α → β), ⨆ x ∈ {a}, s x = s a
|
minpoly.dvd_iff
|
Mathlib.FieldTheory.Minpoly.Field
|
∀ {A : Type u_1} {B : Type u_2} [inst : Field A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B} {p : Polynomial A},
minpoly A x ∣ p ↔ (Polynomial.aeval x) p = 0
|
Std.Iterators.instStreamIterOfProductiveOfIteratorAccessId._proof_1
|
Init.Data.Iterators.Consumers.Stream
|
∀ {α β : Type u_1} [inst : Std.Iterators.Iterator α Id β] (it : Std.Iter β) (it_1 : Std.IterM Id β),
Std.Iterators.IterM.IsPlausibleNthOutputStep 0 it.toIterM (Std.Iterators.IterStep.skip it_1) → False
|
CategoryTheory.GradedObject.ι_mapBifunctorComp₂₃MapObjIso_hom_assoc
|
Mathlib.CategoryTheory.GradedObject.Trifunctor
|
∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6}
[inst : CategoryTheory.Category.{u_14, u_1} C₁] [inst_1 : CategoryTheory.Category.{u_13, u_2} C₂]
[inst_2 : CategoryTheory.Category.{u_12, u_3} C₃] [inst_3 : CategoryTheory.Category.{u_11, u_4} C₄]
[inst_4 : CategoryTheory.Category.{u_15, u_6} C₂₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄))
(G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)) {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9}
{J : Type u_10} {r : I₁ × I₂ × I₃ → J} (ρ₂₃ : CategoryTheory.GradedObject.BifunctorComp₂₃IndexData r)
(X₁ : CategoryTheory.GradedObject I₁ C₁) (X₂ : CategoryTheory.GradedObject I₂ C₂)
(X₃ : CategoryTheory.GradedObject I₃ C₃)
[inst_5 : (((CategoryTheory.GradedObject.mapBifunctor G₂₃ I₂ I₃).obj X₂).obj X₃).HasMap ρ₂₃.p]
[inst_6 :
(((CategoryTheory.GradedObject.mapBifunctor F I₁ ρ₂₃.I₂₃).obj X₁).obj
(CategoryTheory.GradedObject.mapBifunctorMapObj G₂₃ ρ₂₃.p X₂ X₃)).HasMap
ρ₂₃.q]
[H : CategoryTheory.GradedObject.HasGoodTrifunctor₂₃Obj F G₂₃ ρ₂₃ X₁ X₂ X₃]
[inst_7 :
((((CategoryTheory.GradedObject.mapTrifunctor (CategoryTheory.bifunctorComp₂₃ F G₂₃) I₁ I₂ I₃).obj X₁).obj X₂).obj
X₃).HasMap
r]
(i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (j : J) (h : r (i₁, i₂, i₃) = j) {Z : C₄}
(h_1 :
CategoryTheory.GradedObject.mapBifunctorMapObj F ρ₂₃.q X₁
(CategoryTheory.GradedObject.mapBifunctorMapObj G₂₃ ρ₂₃.p X₂ X₃) j ⟶
Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.GradedObject.ιMapTrifunctorMapObj (CategoryTheory.bifunctorComp₂₃ F G₂₃) r X₁ X₂ X₃ i₁ i₂ i₃ j h)
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.GradedObject.mapBifunctorComp₂₃MapObjIso F G₂₃ ρ₂₃ X₁ X₂ X₃).hom j) h_1) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.GradedObject.ιMapBifunctorBifunctor₂₃MapObj F G₂₃ ρ₂₃ X₁ X₂ X₃ i₁ i₂ i₃ j h) h_1
|
Set.biUnion_diff_biUnion_subset
|
Mathlib.Data.Set.Lattice
|
∀ {α : Type u_1} {β : Type u_2} (t : α → Set β) (s₁ s₂ : Set α), (⋃ x ∈ s₁, t x) \ ⋃ x ∈ s₂, t x ⊆ ⋃ x ∈ s₁ \ s₂, t x
|
ContinuousLinearMap.module._proof_1
|
Mathlib.Topology.Algebra.Module.LinearMap
|
∀ {R : Type u_1} {R₃ : Type u_2} {S₃ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₃] [inst_2 : Semiring S₃]
{M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid M] [inst_5 : Module R M] {M₃ : Type u_4}
[inst_6 : TopologicalSpace M₃] [inst_7 : AddCommMonoid M₃] [inst_8 : Module R₃ M₃] [inst_9 : Module S₃ M₃]
[inst_10 : SMulCommClass R₃ S₃ M₃] [inst_11 : ContinuousConstSMul S₃ M₃] {σ₁₃ : R →+* R₃} [inst_12 : ContinuousAdd M₃]
(x x_1 : S₃) (x_2 : M →SL[σ₁₃] M₃), (x + x_1) • x_2 = x • x_2 + x_1 • x_2
|
Lean.Server.FileWorker.handleRpcKeepAlive
|
Lean.Server.FileWorker
|
Lean.Lsp.RpcKeepAliveParams → Lean.Server.FileWorker.WorkerM Unit
|
Function.Periodic.map_vadd_multiples
|
Mathlib.Algebra.Ring.Periodic
|
∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddCommMonoid α],
Function.Periodic f c → ∀ (a : ↥(AddSubmonoid.multiples c)) (x : α), f (a +ᵥ x) = f x
|
integral_log_sin_zero_pi
|
Mathlib.Analysis.SpecialFunctions.Integrals.LogTrigonometric
|
∫ (x : ℝ) in 0..Real.pi, Real.log (Real.sin x) = -Real.log 2 * Real.pi
|
AddMonoidHom.coprod_inl_inr
|
Mathlib.Algebra.Group.Prod
|
∀ {M : Type u_6} {N : Type u_7} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N],
(AddMonoidHom.inl M N).coprod (AddMonoidHom.inr M N) = AddMonoidHom.id (M × N)
|
ArithmeticFunction.sigma_one
|
Mathlib.NumberTheory.ArithmeticFunction.Misc
|
∀ (k : ℕ), (ArithmeticFunction.sigma k) 1 = 1
|
AddChar
|
Mathlib.Algebra.Group.AddChar
|
(A : Type u_1) → [AddMonoid A] → (M : Type u_2) → [Monoid M] → Type (max u_1 u_2)
|
CategoryTheory.Pretriangulated.Triangle.rotate_mor₃
|
Mathlib.CategoryTheory.Triangulated.Rotate
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (T : CategoryTheory.Pretriangulated.Triangle C),
T.rotate.mor₃ = -(CategoryTheory.shiftFunctor C 1).map T.mor₁
|
MulAction.IsBlock.of_orbit
|
Mathlib.GroupTheory.GroupAction.Blocks
|
∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X] {H : Subgroup G} {a : X},
MulAction.stabilizer G a ≤ H → MulAction.IsBlock G (MulAction.orbit (↥H) a)
|
mul_neg_geom_sum
|
Mathlib.Algebra.Ring.GeomSum
|
∀ {R : Type u_1} [inst : Ring R] (x : R) (n : ℕ), (1 - x) * ∑ i ∈ Finset.range n, x ^ i = 1 - x ^ n
|
CompletelyDistribLattice.mk._flat_ctor
|
Mathlib.Order.CompleteBooleanAlgebra
|
{α : Type u} →
(le lt : α → α → Prop) →
(le_refl : ∀ (a : α), le a a) →
(le_trans : ∀ (a b c : α), le a b → le b c → le a c) →
(lt_iff_le_not_ge : autoParam (∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) Preorder.lt_iff_le_not_ge._autoParam) →
(le_antisymm : ∀ (a b : α), le a b → le b a → a = b) →
(sup : α → α → α) →
(le_sup_left : ∀ (a b : α), le a (sup a b)) →
(le_sup_right : ∀ (a b : α), le b (sup a b)) →
(sup_le : ∀ (a b c : α), le a c → le b c → le (sup a b) c) →
(inf : α → α → α) →
(inf_le_left : ∀ (a b : α), le (inf a b) a) →
(inf_le_right : ∀ (a b : α), le (inf a b) b) →
(le_inf : ∀ (a b c : α), le a b → le a c → le a (inf b c)) →
(sSup : Set α → α) →
(∀ (s : Set α), ∀ a ∈ s, le a (sSup s)) →
(∀ (s : Set α) (a : α), (∀ b ∈ s, le b a) → le (sSup s) a) →
(sInf : Set α → α) →
(∀ (s : Set α), ∀ a ∈ s, le (sInf s) a) →
(∀ (s : Set α) (a : α), (∀ b ∈ s, le a b) → le a (sInf s)) →
(top : α) →
(∀ (a : α), le a top) →
(bot : α) →
(∀ (a : α), le bot a) →
(himp : α → α → α) →
(∀ (a b c : α), le a (himp b c) ↔ le (a ⊓ b) c) →
(compl : α → α) →
(∀ (a : α), himp a bot = compl a) →
(sdiff : α → α → α) →
(hnot : α → α) →
(∀ (a b c : α), le (sdiff a b) c ↔ le a (b ⊔ c)) →
(∀ (a : α), sdiff top a = hnot a) →
(∀ {ι : Type u} {κ : ι → Type u}
(f : (a : ι) → κ a → α),
⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a)) →
CompletelyDistribLattice α
|
Lean.Meta.Grind.EMatch.State
|
Lean.Meta.Tactic.Grind.Types
|
Type
|
Configuration.HasLines.rec
|
Mathlib.Combinatorics.Configuration
|
{P : Type u_1} →
{L : Type u_2} →
[inst : Membership P L] →
{motive : Configuration.HasLines P L → Sort u} →
([toNondegenerate : Configuration.Nondegenerate P L] →
(mkLine : {p₁ p₂ : P} → p₁ ≠ p₂ → L) →
(mkLine_ax : ∀ {p₁ p₂ : P} (h : p₁ ≠ p₂), p₁ ∈ mkLine h ∧ p₂ ∈ mkLine h) →
motive { toNondegenerate := toNondegenerate, mkLine := mkLine, mkLine_ax := mkLine_ax }) →
(t : Configuration.HasLines P L) → motive t
|
CategoryTheory.Mod_.noConfusionType
|
Mathlib.CategoryTheory.Monoidal.Mod_
|
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] →
{A : C} →
[inst_4 : CategoryTheory.MonObj A] → Sort u → CategoryTheory.Mod_ D A → CategoryTheory.Mod_ D A → Sort u
|
intervalIntegral.continuousOn_primitive_interval_left
|
Mathlib.MeasureTheory.Integral.DominatedConvergence
|
∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
{f : ℝ → E} [MeasureTheory.NoAtoms μ],
MeasureTheory.IntegrableOn f (Set.uIcc a b) μ → ContinuousOn (fun x => ∫ (t : ℝ) in x..b, f t ∂μ) (Set.uIcc a b)
|
IsPrimitiveRoot.toInteger_sub_one_dvd_prime'
|
Mathlib.NumberTheory.NumberField.Cyclotomic.Basic
|
∀ {p : ℕ} {K : Type u} [inst : Field K] {ζ : K} [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[hcycl : IsCyclotomicExtension {p} ℚ K] (hζ : IsPrimitiveRoot ζ p), hζ.toInteger - 1 ∣ ↑p
|
MulEquiv.coprodAssoc_apply_inl_inl
|
Mathlib.GroupTheory.Coprod.Basic
|
∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : Monoid P] (x : M),
(MulEquiv.coprodAssoc M N P) (Monoid.Coprod.inl (Monoid.Coprod.inl x)) = Monoid.Coprod.inl x
|
ModuleCat.projectiveResolution._proof_1
|
Mathlib.Algebra.Category.ModuleCat.LeftResolution
|
∀ (R : Type u_1) [inst : Ring R] (X : ModuleCat R),
CategoryTheory.isProjective (ModuleCat R) (((CategoryTheory.forget (ModuleCat R)).comp (ModuleCat.free R)).obj X)
|
NumberField.mixedEmbedding.euclidean.instNontrivialMixedSpace
|
Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic
|
∀ (K : Type u_1) [inst : Field K] [NumberField K], Nontrivial (NumberField.mixedEmbedding.euclidean.mixedSpace K)
|
Subsemigroup.subset_closure._simp_3
|
Mathlib.Algebra.Group.Subsemigroup.Basic
|
∀ {M : Type u_1} [inst : Mul M] {s : Set M}, (s ⊆ ↑(Subsemigroup.closure s)) = True
|
Matrix.detp_smul_add_adjp
|
Mathlib.LinearAlgebra.Matrix.SemiringInverse
|
∀ {n : Type u_1} {R : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommSemiring R]
{A B : Matrix n n R}, A * B = 1 → Matrix.detp 1 B • A + Matrix.adjp (-1) B = Matrix.detp (-1) B • A + Matrix.adjp 1 B
|
Ordinal.preOmega_max
|
Mathlib.SetTheory.Cardinal.Aleph
|
∀ (o₁ o₂ : Ordinal.{u_1}), Ordinal.preOmega (max o₁ o₂) = max (Ordinal.preOmega o₁) (Ordinal.preOmega o₂)
|
FiberBundleCore.fiberBundle
|
Mathlib.Topology.FiberBundle.Basic
|
{ι : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
[inst : TopologicalSpace B] → [inst_1 : TopologicalSpace F] → (Z : FiberBundleCore ι B F) → FiberBundle F Z.Fiber
|
_private.Init.Data.List.TakeDrop.0.List.take_left.match_1_1
|
Init.Data.List.TakeDrop
|
∀ {α : Type u_1} (motive : List α → List α → Prop) (x x_1 : List α),
(∀ (x : List α), motive [] x) → (∀ (a : α) (tail x : List α), motive (a :: tail) x) → motive x x_1
|
Lean.Syntax.ident.elim
|
Init.Prelude
|
{motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
t.ctorIdx = 3 →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(val : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) → motive_1 (Lean.Syntax.ident info rawVal val preresolved)) →
motive_1 t
|
LinearMap.domRestrict₁₂_apply
|
Mathlib.LinearAlgebra.BilinearMap
|
∀ {R : Type u_1} [inst : Semiring R] {S : Type u_2} [inst_1 : Semiring S] {R₂ : Type u_3} [inst_2 : Semiring R₂]
{S₂ : Type u_4} [inst_3 : Semiring S₂] {M : Type u_5} {N : Type u_6} {P : Type u_7} [inst_4 : AddCommMonoid M]
[inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P] [inst_7 : Module R M] [inst_8 : Module S N]
[inst_9 : Module R₂ P] [inst_10 : Module S₂ P] [inst_11 : SMulCommClass S₂ R₂ P] {ρ₁₂ : R →+* R₂} {σ₁₂ : S →+* S₂}
(f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (p : Submodule R M) (q : Submodule S N) (x : ↥p) (y : ↥q),
((f.domRestrict₁₂ p q) x) y = (f ↑x) ↑y
|
Lean.Elab.Tactic.GuardMsgs.MessageOrdering._sizeOf_inst
|
Lean.Elab.GuardMsgs
|
SizeOf Lean.Elab.Tactic.GuardMsgs.MessageOrdering
|
HahnEmbedding.Partial.sSup
|
Mathlib.Algebra.Order.Module.HahnEmbedding
|
{K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
[inst_7 : Module K M] →
[inst_8 : IsOrderedModule K M] →
{R : Type u_3} →
[inst_9 : AddCommGroup R] →
[inst_10 : LinearOrder R] →
[inst_11 : Module K R] →
{seed : HahnEmbedding.Seed K M R} →
[IsOrderedAddMonoid R] →
{c : Set (HahnEmbedding.Partial seed)} →
c.Nonempty → DirectedOn (fun x1 x2 => x1 ≤ x2) c → HahnEmbedding.Partial seed
|
_private.Mathlib.Algebra.Order.Field.Power.0.Mathlib.Meta.Positivity.evalZPow._proof_2
|
Mathlib.Algebra.Order.Field.Power
|
∀ {u : Lean.Level} {α : Q(Type u)} (pα : Q(PartialOrder «$α»)) (_a : Q(LinearOrder «$α»)),
«$pα» =Q instDistribLatticeOfLinearOrder.toSemilatticeInf.toPartialOrder
|
List.takeD
|
Batteries.Data.List.Basic
|
{α : Type u_1} → ℕ → List α → α → List α
|
UInt16.lt_add_one
|
Init.Data.UInt.Lemmas
|
∀ {c : UInt16}, c ≠ -1 → c < c + 1
|
Subring.rec
|
Mathlib.Algebra.Ring.Subring.Defs
|
{R : Type u} →
[inst : Ring R] →
{motive : Subring R → Sort u_1} →
((toSubsemiring : Subsemiring R) →
(neg_mem' : ∀ {x : R}, x ∈ toSubsemiring.carrier → -x ∈ toSubsemiring.carrier) →
motive { toSubsemiring := toSubsemiring, neg_mem' := neg_mem' }) →
(t : Subring R) → motive t
|
UniformEquiv.piCongrLeft
|
Mathlib.Topology.UniformSpace.Equiv
|
{ι : Type u_4} →
{ι' : Type u_5} →
{β : ι' → Type u_6} →
[inst : (j : ι') → UniformSpace (β j)] → (e : ι ≃ ι') → ((i : ι) → β (e i)) ≃ᵤ ((j : ι') → β j)
|
_private.Mathlib.Order.Filter.ENNReal.0.NNReal.toReal_liminf._simp_1_6
|
Mathlib.Order.Filter.ENNReal
|
∀ {q : NNReal}, (0 ≤ ↑q) = True
|
MeasureTheory.SimpleFunc.GCongr.coe_le_coe
|
Mathlib.MeasureTheory.Function.SimpleFunc
|
∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Preorder β] {f g : MeasureTheory.SimpleFunc α β},
f ≤ g → ⇑f ≤ ⇑g
|
Batteries.RBNode.Balanced.map
|
Batteries.Data.RBMap.WF
|
∀ {α : Type u_1} {c : Batteries.RBColor} {n : ℕ} {α_1 : Type u_2} {f : α → α_1} {t : Batteries.RBNode α},
t.Balanced c n → (Batteries.RBNode.map f t).Balanced c n
|
Lean.PersistentHashMap.isUnaryEntries
|
Lean.Data.PersistentHashMap
|
{α : Type u_1} →
{β : Type u_2} →
Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → ℕ → Option (α × β) → Option (α × β)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.