name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
UInt32._sizeOf_inst._@.Mathlib.Util.CompileInductive.3310122970._hygCtx._hyg.271 | Mathlib.Util.CompileInductive | SizeOf UInt32 | null | false |
CategoryTheory.exactPairingCongrLeft._proof_6 | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X X' : C}
(i : X ≅ X'),
CategoryTheory.monoidalComp
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) X))
... | null | false |
Int.cast_multiset_sum | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {R : Type u_4} [inst : AddCommGroupWithOne R] (s : Multiset ℤ), ↑s.sum = (Multiset.map Int.cast s).sum | null | true |
FirstOrder.Language.BoundedFormula.equal.sizeOf_spec | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u'} [inst : SizeOf α] {n : ℕ} (t₁ t₂ : L.Term (α ⊕ Fin n)),
sizeOf (FirstOrder.Language.BoundedFormula.equal t₁ t₂) = 1 + sizeOf n + sizeOf t₁ + sizeOf t₂ | null | true |
_private.Std.Async.Timer.0.Std.Async.Sleep.ofNative._flat_ctor | Std.Async.Timer | Std.Internal.UV.Timer → Std.Async.Sleep | null | false |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr.noConfusionType | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Sort u → Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Sort u | null | false |
Subsemiring.instCompleteLattice._proof_7 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (s : Subsemiring R), ∀ x ∈ ⊥, x ∈ s | null | false |
_private.Mathlib.Algebra.Order.Floor.Ring.0.Mathlib.Meta.Positivity.evalIntFloor.match_4 | Mathlib.Algebra.Order.Floor.Ring | {u : Lean.Level} →
{α : Q(Type u)} →
(motive : Option Q(PartialOrder «$α») → Sort u_1) →
(pα? : Option Q(PartialOrder «$α»)) →
(Unit → motive none) → ((val : Q(PartialOrder «$α»)) → motive (some val)) → motive pα? | null | false |
_private.Batteries.Data.Array.Basic.0.Array.scanlMFast.loop | Batteries.Data.Array.Basic | {m : Type u_1 → Type u_2} →
{β : Type u_1} →
{α : Type u_3} →
[Monad m] →
(β → α → m β) → β → (as : Array α) → USize → (stop : USize) → stop.toNat ≤ as.size → Array β → m (Array β) | null | true |
CategoryTheory.Adjunction.leftAdjointCompIso | Mathlib.CategoryTheory.Adjunction.CompositionIso | {C₀ : Type u_1} →
{C₁ : Type u_2} →
{C₂ : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C₀] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₁] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₂] →
{F₀₁ : CategoryTheory.Functor C₀ C₁} →
{F₁₂ : CategoryTheor... | A natural isomorphism `G₂₁ ⋙ G₁₀ ≅ G₂₀` involving right adjoint functors
induces a natural isomorphism `F₀₁ ⋙ F₁₂ ≅ F₀₂` between the corresponding
left adjoint functors. | true |
Dynamics.coverEntropyInfEntourage_antitone | Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | ∀ {X : Type u_1} (T : X → X) (F : Set X), Antitone fun U => Dynamics.coverEntropyInfEntourage T F U | null | true |
Nat.succ_le_of_lt | Init.Data.Nat.Basic | ∀ {n m : ℕ}, n < m → n.succ ≤ m | null | true |
_private.Mathlib.LinearAlgebra.TensorAlgebra.Basis.0.TensorAlgebra.rank_eq.match_1_1 | Mathlib.LinearAlgebra.TensorAlgebra.Basis | ∀ {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : Nonempty ((I : Type u_1) × Module.Basis I R M) → Prop) (x : Nonempty ((I : Type u_1) × Module.Basis I R M)),
(∀ (κ : Type u_1) (b : Module.Basis κ R M), motive ⋯) → motive x | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.mkEMatchTheoremWithKind?._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | {motive : Lean.Meta.Grind.EMatchTheoremKind → Sort u} →
(t : Lean.Meta.Grind.EMatchTheoremKind) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqLhs gen)) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqRhs gen)) →
motive Lean.Meta.Grind.EMatchTheoremKind.eqBwd → (Nat.hasN... | null | false |
Array.getElem?_attach | Init.Data.Array.Attach | ∀ {α : Type u_1} {xs : Array α} {i : ℕ}, xs.attach[i]? = Option.pmap Subtype.mk xs[i]? ⋯ | null | true |
Rat.interior_compact_eq_empty | Mathlib.Topology.Instances.RatLemmas | ∀ {s : Set ℚ}, IsCompact s → interior s = ∅ | null | true |
Lean.Parser.OrElseOnAntiquotBehavior.merge.sizeOf_spec | Lean.Parser.Basic | sizeOf Lean.Parser.OrElseOnAntiquotBehavior.merge = 1 | null | true |
_private.Mathlib.Probability.Moments.SubGaussian.0.ProbabilityTheory.HasSubgaussianMGF_iff_kernel.match_1_3 | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : Ω → ℝ} {c : NNReal}
(motive :
ProbabilityTheory.Kernel.HasSubgaussianMGF X c (ProbabilityTheory.Kernel.const Unit μ)
(MeasureTheory.Measure.dirac ()) →
Prop)
(x :
ProbabilityTheory.Kernel.HasSubgaussianMGF X c (Probab... | null | false |
NormedAddGroupHom._sizeOf_1 | Mathlib.Analysis.Normed.Group.Hom | {V : Type u_1} →
{W : Type u_2} →
{inst : SeminormedAddCommGroup V} →
{inst_1 : SeminormedAddCommGroup W} → [SizeOf V] → [SizeOf W] → NormedAddGroupHom V W → ℕ | null | false |
MulArchimedeanOrder.val.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1}, MulArchimedeanOrder.val = Equiv.refl (MulArchimedeanOrder M) | null | true |
MeasurableSMul.rec | Mathlib.MeasureTheory.Group.Arithmetic | {M : Type u_2} →
{α : Type u_3} →
[inst : SMul M α] →
[inst_1 : MeasurableSpace M] →
[inst_2 : MeasurableSpace α] →
{motive : MeasurableSMul M α → Sort u} →
([toMeasurableConstSMul : MeasurableConstSMul M α] →
(measurable_smul_const : ∀ (x : α), Measurable fun x... | null | false |
Lean.Meta.Grind.AC.DiseqCnstrProof.simp_middle | Lean.Meta.Tactic.Grind.AC.Types | Bool →
Lean.Grind.AC.Seq →
Lean.Grind.AC.Seq → Lean.Meta.Grind.AC.EqCnstr → Lean.Meta.Grind.AC.DiseqCnstr → Lean.Meta.Grind.AC.DiseqCnstrProof | null | true |
Std.ExtHashMap.contains_of_contains_filterMap | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → Option γ} {k : α},
(Std.ExtHashMap.filterMap f m).contains k = true → m.contains k = true | null | true |
Complex.UnitDisc.mk_neg | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (z : ℂ) (hz : ‖-z‖ < 1), Complex.UnitDisc.mk (-z) hz = -Complex.UnitDisc.mk z ⋯ | null | true |
ValuativeRel.trivialRel._proof_5 | Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | ∀ {R : Type} [inst : Semiring R] [inst_1 : DecidableEq R] [IsDomain R] {x y z : R},
(¬if 0 = 0 then z = 0 else True) → (if y * z = 0 then x * z = 0 else True) → if y = 0 then x = 0 else True | null | false |
Lean.Linter.LintEntry.message | Lean.Linter.PersistentLintLog | Lean.Linter.LintEntry → Lean.SerialMessage | null | true |
PowerBasis.liftEquiv._proof_6 | Mathlib.RingTheory.PowerBasis | ∀ {S : Type u_3} [inst : Ring S] {A : Type u_2} [inst_1 : CommRing A] [inst_2 : Algebra A S] {S' : Type u_1}
[inst_3 : Ring S'] [inst_4 : Algebra A S'] (pb : PowerBasis A S)
(y : { y // (Polynomial.aeval y) (minpoly A pb.gen) = 0 }), ⟨(pb.lift ↑y ⋯) pb.gen, ⋯⟩ = y | null | false |
Mathlib.Tactic.superscriptTerm | Mathlib.Util.Superscript | Lean.Parser.Parser | Shorthand for `superscript(term)`.
This is needed because the initializer below does not always run, and if it has not run then
downstream parsers using the combinators will crash.
See https://leanprover.zulipchat.com/#narrow/channel/270676-lean4/topic/Non-builtin.20parser.20aliases/near/365125476
for some context. | true |
_private.Mathlib.Order.SuccPred.CompleteLinearOrder.0.lt_sInf_iff_of_not_isPredPrelimit.match_1_1 | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] {x : α} (motive : (∃ b, x ⋖ b) → Prop) (x_1 : ∃ b, x ⋖ b),
(∀ (y : α) (hy : x ⋖ y), motive ⋯) → motive x_1 | null | false |
CategoryTheory.effectiveEpiFamilyStructOfComp._proof_4 | Mathlib.CategoryTheory.EffectiveEpi.Comp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {Z Y : I → C} {X : C}
(g : (i : I) → Z i ⟶ Y i) (f : (i : I) → Y i ⟶ X)
[inst_1 : CategoryTheory.EffectiveEpiFamily Z fun i => CategoryTheory.CategoryStruct.comp (g i) (f i)] {W : C}
(φ : (a : I) → Y a ⟶ W)
(x :
∀ {Z : C} (a₁ a₂ :... | null | false |
_private.Mathlib.Algebra.Order.Archimedean.Basic.0.existsUnique_div_zpow_mem_Ico._simp_1_1 | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ico a b) = (a ≤ x ∧ x < b) | null | false |
AlternatingMap.instFunLike._proof_1 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_4} [inst : Semiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_3} (f g : M [⋀^ι]→ₗ[R] N),
(fun f => (↑f).toFun) f = (fun f => (↑f).toFun) g → f = g | null | false |
AlgebraicGeometry.Scheme.Cover.map_prop | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | ∀ {X : AlgebraicGeometry.Scheme} {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) (i : 𝒰.I₀), P (𝒰.f i) | null | true |
Condensed.StoneanCompHaus.equivalence._proof_5 | Mathlib.Condensed.Equivalence | CategoryTheory.FinitaryPreExtensive Stonean | null | false |
_private.Mathlib.Tactic.FunProp.Mor.0.Mathlib.Meta.FunProp.Mor.whnfPred.match_3 | Mathlib.Tactic.FunProp.Mor | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) → ((e : Lean.Expr) → motive (some e)) → (Unit → motive none) → motive __do_lift | null | false |
_private.Mathlib.Analysis.Normed.Operator.BoundedLinearMaps.0.IsBoundedLinearMap.isBigO_id.match_1_1 | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {E : Type u_2} {F : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] {f : E → F}
(motive : (∃ M, 0 < M ∧ ∀ (x : E), ‖f x‖ ≤ M * ‖x‖) → Prop) (x : ∃ M, 0 < M ∧ ∀ (x : E), ‖f x‖ ≤ M * ‖x‖),
(∀ (w : ℝ) (left : 0 < w) (hM : ∀ (x : E), ‖f x‖ ≤ w * ‖x‖), motive ⋯) → motive x | null | false |
Subgroup.index_centralizer_eq_ncard | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] (g : G), (Subgroup.centralizer {g}).index = (conjugatesOf g).ncard | null | true |
CategoryTheory.TransfiniteCompositionOfShape.incl | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{X Y : C} →
{f : X ⟶ Y} →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
(self : CategoryTheory.Tr... | the natural morphism `F.obj j ⟶ Y` | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt.0.HasProd.hasProd_symmetricIco_of_hasProd_symmetricIcc._proof_1_3 | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ (N : ℕ), -↑N ≤ ↑N | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.IsCycleOn.pow_apply_eq_pow_apply._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (y = e.symm x) = (e y = x) | null | false |
Lean.Order.coind_monotone_forall | Init.Internal.Order.Basic | ∀ {α : Sort u_1} [inst : Lean.Order.PartialOrder α] {β : Sort u_2} (f : α → β → Lean.Order.ReverseImplicationOrder),
Lean.Order.monotone f → Lean.Order.monotone fun x => ∀ (y : β), f x y | null | true |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.isLongestRevMatchAtChain_iff_toList._simp_1_2 | Init.Data.String.Lemmas.Pattern.Char | ∀ {p : Char → Bool} {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAtChain p pos pos' =
∃ (h : pos ≤ pos'), ∀ c ∈ (s.slice pos pos' h).copy.toList, p c = true | null | false |
Std.Http.Server.Connection._sizeOf_1 | Std.Http.Server.Connection | {α : Type} → [SizeOf α] → Std.Http.Server.Connection α → ℕ | null | false |
CategoryTheory.GlueData'.t''._proof_7 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (D : CategoryTheory.GlueData' C) (i j k : D.J)
(hij : ¬i = j) (hjk : ¬j = k), CategoryTheory.Limits.HasPullback (D.f j k hjk) (D.f j i ⋯) | null | false |
BoundedContinuousFunction.probCharDual._proof_13 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | ∀ {F : Type u_1} [inst : SeminormedAddCommGroup F] [inst_1 : NormedSpace ℝ F],
Continuous fun p => (p.2, p.1).1 (p.2, p.1).2 | null | false |
Lean.ParserDescr.unicodeSymbol | Init.Prelude | String → String → Bool → Lean.ParserDescr | - `unicode("→", "->")` parses a symbol matching either `→` or `->`. Each symbol is reserved.
The second symbol is an ASCII version of the first.
The `pp.unicode` option controls which is used when pretty printing.
- `unicode("→", "->", preserveForPP)` is the same except for pretty printing behavior.
When the `pp... | true |
Module.Dual.baseChange._proof_2 | Mathlib.LinearAlgebra.Dual.BaseChange | ∀ {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : CommSemiring A] [inst_2 : Algebra R A],
SMulCommClass R A A | null | false |
Cardinal.partialOrder._proof_2 | Mathlib.SetTheory.Cardinal.Order | ∀ (a b c : Cardinal.{u_1}), a ≤ b → b ≤ c → a ≤ c | null | false |
UpperHalfPlane.petersson_slash_SL | Mathlib.NumberTheory.ModularForms.Petersson | ∀ (k : ℤ) (f f' : UpperHalfPlane → ℂ) (g : Matrix.SpecialLinearGroup (Fin 2) ℤ) (τ : UpperHalfPlane),
UpperHalfPlane.petersson k (SlashAction.map k g f) (SlashAction.map k g f') τ =
UpperHalfPlane.petersson k f f' (g • τ) | null | true |
CategoryTheory.CostructuredArrow.map_mk | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T T' : D} {Y : C} {S : CategoryTheory.Functor C D} {f : S.obj Y ⟶ T} (g : T ⟶ T'),
(CategoryTheory.CostructuredArrow.map g).obj (CategoryTheory.CostructuredArrow.mk f) =
CategoryTheory.Costru... | null | true |
_private.Lean.Compiler.LCNF.Simp.FunDeclInfo.0.Lean.Compiler.LCNF.Simp.FunDeclInfoMap.update.addLetValueOccs | Lean.Compiler.LCNF.Simp.FunDeclInfo | Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure →
StateRefT' IO.RealWorld Lean.Compiler.LCNF.Simp.FunDeclInfoMap Lean.Compiler.LCNF.CompilerM Unit | null | true |
DilationEquiv.recOn | Mathlib.Topology.MetricSpace.DilationEquiv | {X : Type u_1} →
{Y : Type u_2} →
[inst : PseudoEMetricSpace X] →
[inst_1 : PseudoEMetricSpace Y] →
{motive : X ≃ᵈ Y → Sort u} →
(t : X ≃ᵈ Y) →
((toEquiv : X ≃ Y) →
(edist_eq' : ∃ r, r ≠ 0 ∧ ∀ (x y : X), edist (toEquiv.toFun x) (toEquiv.toFun y) = ↑r * edist x y... | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order.0.CStarAlgebra.norm_posPart_mono._simp_1_6 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a * a = a ^ 3 | null | false |
Function.Injective.addMonoid._proof_3 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₁] [inst_1 : Zero M₁] [inst_2 : SMul ℕ M₁] [inst_3 : AddMonoid M₂]
(f : M₁ → M₂) (hf : Function.Injective f) (zero : f 0 = 0) (add : ∀ (x y : M₁), f (x + y) = f x + f y),
(∀ (x : M₁) (n : ℕ), f (n • x) = n • f x) → ∀ (x : M₁), 0 • x = 0 | null | false |
CondensedSet.topCatAdjunctionUnit | Mathlib.Condensed.TopCatAdjunction | (X : CondensedSet) → X ⟶ X.toTopCat.toCondensedSet | The unit of the adjunction `condensedSetToTopCat ⊣ topCatToCondensedSet` | true |
AlgebraicTopology.DoldKan.QInfty_comp_PInfty_assoc | Mathlib.AlgebraicTopology.DoldKan.PInfty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {Z : ChainComplex C ℕ}
(h : AlgebraicTopology.AlternatingFaceMapComplex.obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp AlgebraicTopology.DoldKan.QInfty
(CategoryTheo... | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.isSubstCandidate | Lean.Elab.BuiltinNotation | Lean.Expr → Lean.Expr → Lean.MetaM Bool | Return `true` if `lhs` is a free variable and `rhs` does not depend on it. | true |
Order.isSuccPrelimit_toDual_iff | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : LT α], Order.IsSuccPrelimit (OrderDual.toDual a) ↔ Order.IsPredPrelimit a | null | true |
OpenAddSubgroup.toAddSubgroup_sup._simp_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : SeparatelyContinuousAdd G]
(U V : OpenAddSubgroup G), ↑U ⊔ ↑V = ↑(U ⊔ V) | null | false |
FirstOrder.Field.FieldAxiom.toProp.eq_7 | Mathlib.ModelTheory.Algebra.Field.Basic | ∀ (K : Type u_2) [inst : Add K] [inst_1 : Mul K] [inst_2 : Neg K] [inst_3 : Zero K] [inst_4 : One K],
FirstOrder.Field.FieldAxiom.toProp K FirstOrder.Field.FieldAxiom.existsInv = ∀ (x : K), x ≠ 0 → ∃ y, x * y = 1 | null | true |
CategoryTheory.Limits.PreservesFiniteProducts.casesOn | Mathlib.CategoryTheory.Limits.Preserves.Finite | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : CategoryTheory.Limits.PreservesFiniteProducts F → Sort u} →
(t : CategoryTheory.Limits.PreservesFiniteProdu... | null | false |
CommRingCat.Colimits.ColimitType.AddGroupWithOne._proof_3 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat) (n : ℕ),
(↑n).castDef = ↑n | null | false |
ContinuousMap.instNormedAlgebra._proof_2 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] {𝕜 : Type u_3} {γ : Type u_2} [inst_1 : NormedField 𝕜]
[inst_2 : SeminormedRing γ] [inst_3 : NormedAlgebra 𝕜 γ] (r : 𝕜) (x : C(α, γ)),
(algebraMap 𝕜 C(α, γ)) r * x = x * (algebraMap 𝕜 C(α, γ)) r | null | false |
smoothPresheafRing | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_2} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_3} →
[inst_3 : TopologicalSpace HM] →
ModelWithCorners 𝕜 EM HM →
{E : Type u_4} →
... | The presheaf of smooth functions from `M` to `R`, for `R` a smooth ring, as a presheaf
of rings. | true |
ContinuousMap.instNonUnitalSemiringOfIsTopologicalSemiring._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : NonUnitalSemiring β]
[inst_3 : IsTopologicalSemiring β] (a b c : C(α, β)), a * b * c = a * (b * c) | null | false |
Matrix.l2_opNNNorm_conjTranspose | Mathlib.Analysis.CStarAlgebra.Matrix | ∀ {𝕜 : Type u_1} {m : Type u_2} {n : Type u_3} [inst : RCLike 𝕜] [inst_1 : Fintype m] [inst_2 : Fintype n]
[inst_3 : DecidableEq n] [inst_4 : DecidableEq m] (A : Matrix m n 𝕜), ‖A.conjTranspose‖₊ = ‖A‖₊ | null | true |
LT.lt.pos | Mathlib.Algebra.Order.IsBotOne | ∀ {α : Type u_1} {a b : α} [inst : Preorder α] [inst_1 : Zero α] [IsBotZeroClass α], a < b → 0 < b | **Alias** of `pos_of_gt`. | true |
_private.Lean.Elab.PreDefinition.TerminationMeasure.0.Lean.Elab.TerminationMeasure.delab.go.match_1.splitter | Lean.Elab.PreDefinition.TerminationMeasure | (motive : ℕ → Lean.TSyntaxArray `ident → Sort u_1) →
(x : ℕ) →
(x_1 : Lean.TSyntaxArray `ident) →
((vars : Lean.TSyntaxArray `ident) → motive 0 vars) →
((i : ℕ) → (vars : Lean.TSyntaxArray `ident) → motive i.succ vars) → motive x x_1 | null | true |
LieAlgebra.exists_isRegular | Mathlib.Algebra.Lie.Rank | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : Module.Finite R L] [inst_4 : Module.Free R L] [IsDomain R] [Infinite R], ∃ x, LieAlgebra.IsRegular R x | null | true |
ISize.le_iff_toBitVec32_sle._simp_1 | Init.Data.SInt.IntToBitVec | ∀ {a b : ISize} (h : System.Platform.numBits = 32), (a ≤ b) = ((a.toBitVec32 h).sle (b.toBitVec32 h) = true) | null | false |
CategoryTheory.MorphismProperty.LeftFraction.f | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} → {X Y : C} → (self : W.LeftFraction X Y) → X ⟶ self.Y' | the numerator of a left fraction | true |
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.Subgraph.isMatching_iff_forall_degree._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {V : Type u} {G : SimpleGraph V} {G' : G.Subgraph} {v : V} [inst : Fintype ↑(G'.neighborSet v)],
(G'.degree v = 1) = ∃! w, G'.Adj v w | null | false |
NFA.accepts_iff_exists_path | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} {M : NFA α σ} {x : List α},
x ∈ M.accepts ↔ ∃ s ∈ M.start, ∃ t ∈ M.accept, Nonempty (M.Path s t x) | null | true |
Multiset.mem_sym2_iff | Mathlib.Data.Multiset.Sym | ∀ {α : Type u_1} {m : Multiset α} {z : Sym2 α}, z ∈ m.sym2 ↔ ∀ y ∈ z, y ∈ m | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc.0.CategoryTheory.Limits.termG₃ | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | Lean.ParserDescr | null | true |
MeasureTheory.probReal_add_probReal_compl | Mathlib.MeasureTheory.Measure.Typeclasses.Probability | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}
[MeasureTheory.IsProbabilityMeasure μ], MeasurableSet s → μ.real s + μ.real sᶜ = 1 | null | true |
Function.mem_support | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {x : ι}, x ∈ Function.support f ↔ f x ≠ 0 | null | true |
_private.Init.Meta.Defs.0.Lean.Syntax.decodeNameLit.match_1 | Init.Meta.Defs | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) → (Unit → motive Lean.Name.anonymous) → ((name : Lean.Name) → motive name) → motive x | null | false |
_private.Lean.Meta.ExprLens.0.Lean.Meta.foldAncestorsAux._unsafe_rec | Lean.Meta.ExprLens | {M : Type → Type} →
[Monad M] →
[MonadLiftT Lean.MetaM M] →
[MonadControlT Lean.MetaM M] →
[Lean.MonadError M] →
{α : Type} → (Array Lean.Expr → Lean.Expr → ℕ → α → M α) → α → List ℕ → Array Lean.Expr → Lean.Expr → M α | null | false |
CategoryTheory.Limits.ConeMorphism.ext | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {c c' : CategoryTheory.Limits.Cone F} (f g : c ⟶ c'), f.hom = g.hom → f = g | null | true |
LinearMap.compAlternatingMap_smul | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7} {S : Type u_10} {N₂ : Type u_11}
[inst_5 : AddCommMonoid N₂] [inst_6 : Module R N₂] [inst_7 : Monoid S] [inst_8 : DistribMulAction S N]
... | null | true |
Float.Model.UnpackedFloat.Sign.negative | Init.Data.Float.Model.Unpacked.Sign | Float.Model.UnpackedFloat.Sign | Negative (`-`) sign. | true |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.solve.match_8 | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
(α : Q(Type u)) →
(e : Q(«$α»)) →
(zα : Q(Zero «$α»)) →
(motive : (pα? : Option Q(PartialOrder «$α»)) → Mathlib.Meta.Positivity.Strictness zα e pα? → Sort u_1) →
(pα? : Option Q(PartialOrder «$α»)) →
(r : Mathlib.Meta.Positivity.Strictness zα e pα?) →
... | null | false |
Nat.getElem?_toArray_roc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, (m<...=n).toArray[i]? = if i < n - m then some (m + 1 + i) else none | null | true |
Module.Basis.isUnitSMul | Mathlib.LinearAlgebra.Basis.SMul | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_4} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] → Module.Basis ι R M → {w : ι → R} → (∀ (i : ι), IsUnit (w i)) → Module.Basis ι R M | A version of `unitsSMul` that uses `IsUnit`. | true |
_private.Mathlib.RingTheory.AdicCompletion.LocalRing.0.AdicCompletion.spanFinrank_maximalIdeal_eq._simp_1_3 | Mathlib.RingTheory.AdicCompletion.LocalRing | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
squarefree_iff_irreducible_sq_not_dvd_of_ne_zero | Mathlib.Algebra.Squarefree.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [WfDvdMonoid R] {r : R},
r ≠ 0 → (Squarefree r ↔ ∀ (x : R), Irreducible x → ¬x * x ∣ r) | null | true |
DiffContOnCl.circleAverage | Mathlib.Analysis.Complex.MeanValue | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] [CompleteSpace E] {f : ℂ → E} {R : ℝ} {c : ℂ},
DiffContOnCl ℂ f (Metric.ball c |R|) → Real.circleAverage f c R = f c | The **Mean Value Property** of complex differentiable functions: If `f : ℂ → E` is complex
differentiable at all points of a closed disc of radius `R` and center `c`, then the circle average
`circleAverage f c R` equals `f c`.
| true |
Int.negSucc_shiftRight | Init.Data.Int.Bitwise.Lemmas | ∀ (m n : ℕ), Int.negSucc m >>> n = Int.negSucc (m >>> n) | null | true |
OnePoint.not_specializes_infty_coe | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, ¬OnePoint.infty ⤳ ↑x | null | true |
Aesop.traceSimpTheoremTreeContents | Aesop.Tracing | Lean.Meta.SimpTheoremTree → Aesop.TraceOption → Lean.CoreM Unit | null | true |
IsFreeGroupoid.SpanningTree.treeHom.eq_1 | Mathlib.GroupTheory.FreeGroup.NielsenSchreier | ∀ {G : Type u} [inst : CategoryTheory.Groupoid G] [inst_1 : IsFreeGroupoid G]
(T : WideSubquiver (Quiver.Symmetrify (IsFreeGroupoid.Generators G)))
[inst_2 : Quiver.Arborescence (WideSubquiver.toType (Quiver.Symmetrify (IsFreeGroupoid.Generators G)) T)] (a : G),
IsFreeGroupoid.SpanningTree.treeHom T a = IsFreeGro... | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transformObjComp_inv_app_fst_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {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]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheor... | null | true |
HopfAlgCat.tensorUnit_carrier | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u) [inst : CommRing R], (CategoryTheory.MonoidalCategoryStruct.tensorUnit (HopfAlgCat R)).carrier = R | null | true |
LawfulFix.mk._flat_ctor | Mathlib.Control.LawfulFix | {α : Type u_3} →
[inst : OmegaCompletePartialOrder α] →
(fix : (α → α) → α) →
(∀ {f : α → α}, OmegaCompletePartialOrder.ωScottContinuous f → fix f = f (fix f)) → LawfulFix α | null | false |
CategoryTheory.Limits.coequalizer.isoTargetOfSelf_inv | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] (f : Y ⟶ X),
(CategoryTheory.Limits.coequalizer.isoTargetOfSelf f).inv = CategoryTheory.Limits.coequalizer.π f f | null | true |
Real.le_sqrt' | Mathlib.Analysis.Real.Sqrt | ∀ {x y : ℝ}, 0 < x → (x ≤ √y ↔ x ^ 2 ≤ y) | null | true |
_private.ImportGraph.Shake.DeclNeeds.0.ImportGraph.Shake.calcDeclConstInfoNeeds.visitExpr.match_3 | ImportGraph.Shake.DeclNeeds | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → ((c : Lean.Name) → motive (some c)) → ((x : Option Lean.Name) → motive x) → motive x | null | false |
Set.disjoint_of_subset_iff_left_eq_empty | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → (Disjoint s t ↔ s = ∅) | null | true |
MeasureTheory.Lp.instLattice | Mathlib.MeasureTheory.Function.LpOrder | {α : Type u_1} →
{E : Type u_2} →
{m : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} →
{p : ENNReal} →
[inst : NormedAddCommGroup E] →
[inst_1 : Lattice E] → [HasSolidNorm E] → [IsOrderedAddMonoid E] → Lattice ↥(MeasureTheory.Lp E p μ) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.