name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
instMetricSpaceOrderDual | Mathlib.Topology.MetricSpace.Defs | {X : Type u_1} → [MetricSpace X] → MetricSpace Xᵒᵈ | null | true |
_private.Mathlib.Order.Partition.Basic.0.Partition.instSemilatticeInf._proof_11 | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} [inst : Order.Frame α] (s : α) (P : Partition s), ∀ p ∈ P, ∀ (q : α), ∃ y ∈ P, p ⊓ q ≤ y | null | false |
groupHomology.chainsMap._proof_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k : Type u_1} [inst : CommRing k], RingHomCompTriple (RingHom.id k) (RingHom.id k) (RingHom.id k) | null | false |
MeasureTheory.AEStronglyMeasurable.fun_vadd | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{𝕜 : Type u_5} [inst_1 : TopologicalSpace 𝕜] [inst_2 : VAdd 𝕜 β] [ContinuousVAdd 𝕜 β] {f : α → 𝕜} {g : α → β},
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory.AEStronglyMeasurable g μ... | null | true |
eq_nnratCast | Mathlib.Data.Rat.Cast.Defs | ∀ {F : Type u_1} {α : Type u_2} [inst : DivisionSemiring α] [inst_1 : FunLike F ℚ≥0 α] [RingHomClass F ℚ≥0 α] (f : F)
(q : ℚ≥0), f q = ↑q | null | true |
List.prod_nat_mod | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ (l : List ℕ) (n : ℕ), l.prod % n = (List.map (fun x => x % n) l).prod % n | null | true |
Archimedean.ratLt'.eq_1 | Mathlib.Basic.Real.Embedding | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : One M] (x : M),
Archimedean.ratLt' x = ⇑(Rat.castHom ℝ) '' Archimedean.ratLt x | null | true |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.initCore | Lean.Meta.Tactic.Grind.Main | Lean.MVarId → Lean.Meta.Grind.GrindM Lean.Meta.Grind.Goal | null | true |
Lean.Elab.Term.LetConfig.rec | Lean.Elab.Binders | {motive : Lean.Elab.Term.LetConfig → Sort u} →
((nondep usedOnly zeta postponeValue generalize : Bool) →
(eq? : Option Lean.Ident) →
motive
{ nondep := nondep, usedOnly := usedOnly, zeta := zeta, postponeValue := postponeValue,
generalize := generalize, eq? := eq? }) →
(t : Lea... | null | false |
YoungDiagram.cells_subset_iff | Mathlib.Combinatorics.Young.YoungDiagram | ∀ {μ ν : YoungDiagram}, μ.cells ⊆ ν.cells ↔ μ ≤ ν | null | true |
CauSeq.Completion.ofRat_neg | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x : β),
CauSeq.Completion.ofRat (-x) = -CauSeq.Completion.ofRat x | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity.0.continuousOn_cfc_setProd_nhdsSet.match_1_7 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {𝕜 : Type u_1} {A : Type u_2} {p : A → Prop} [inst : RCLike 𝕜] [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
{s : Set 𝕜} (k : Set 𝕜) (f : UniformOnFun 𝕜 𝕜 {t | IsCompact t ∧ t ⊆ s}) (a : A)
(motive :
(f, a) ∈
{f | ContinuousOn ((UniformOnFun.toFun {t | IsCompact t ∧ t ⊆ s}) f) s} ×ˢ
... | null | false |
AddSubgroup.exists_finset_card_le_add | Mathlib.GroupTheory.Schreier | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) [H.FiniteIndex] {S : Finset G},
AddSubgroup.closure ↑S = ⊤ → ∃ T, T.card ≤ H.index * S.card ∧ AddSubgroup.closure ↑T = ⊤ | null | true |
Array.eraseP_map | Init.Data.Array.Erase | ∀ {β : Type u_1} {α : Type u_2} {p : α → Bool} {f : β → α} {xs : Array β},
(Array.map f xs).eraseP p = Array.map f (xs.eraseP (p ∘ f)) | null | true |
PerfectClosure.instCommRing._proof_18 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
(a : PerfectClosure K p), 0 • a = 0 | null | false |
Std.Internal.UV.System.GroupInfo | Std.Internal.UV.System | Type | Information about the current group,
| true |
AlgebraicGeometry.IsSeparated.of_comp | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z)
[AlgebraicGeometry.IsSeparated (CategoryTheory.CategoryStruct.comp f g)], AlgebraicGeometry.IsSeparated f | null | true |
CategoryTheory.AddGrpObj.ofIso._proof_3 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G' X : C} [inst_2 : CategoryTheory.AddGrpObj G'] (e : G' ≅ X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.CategoryStruct.id X)
(C... | null | false |
Topology.IsUpper.isTopologicalSpace_basis | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] [t : TopologicalSpace α] [Topology.IsUpper α] (U : Set α),
IsOpen U ↔ U = Set.univ ∨ ∃ a, (Set.Iic a)ᶜ = U | null | true |
CategoryTheory.Limits.IsTerminal.isSplitMono_from | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (t : CategoryTheory.Limits.IsTerminal X)
(f : X ⟶ Y), CategoryTheory.IsSplitMono f | Any morphism from a terminal object is split mono. | true |
_private.Mathlib.Topology.Order.LeftRightNhds.0.eventually_mabs_div_lt._simp_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u} (s : Set α), (s ∈ Filter.principal s) = True | null | false |
Lean.Lsp.DidSaveTextDocumentParams.mk.noConfusion | Lean.Data.Lsp.TextSync | {P : Sort u} →
{textDocument : Lean.Lsp.TextDocumentIdentifier} →
{text? : Option String} →
{textDocument' : Lean.Lsp.TextDocumentIdentifier} →
{text?' : Option String} →
{ textDocument := textDocument, text? := text? } = { textDocument := textDocument', text? := text?' } →
(te... | null | false |
AddEquivClass.map_add | Mathlib.Algebra.Group.Equiv.Defs | ∀ {F : Type u_9} {A : outParam (Type u_10)} {B : outParam (Type u_11)} {inst : Add A} {inst_1 : Add B}
{inst_2 : EquivLike F A B} [self : AddEquivClass F A B] (f : F) (a b : A), f (a + b) = f a + f b | Preserves addition. | true |
CategoryTheory.Factorisation.comp_h_assoc | Mathlib.CategoryTheory.Category.Factorisation | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
{X_1 Y_1 Z : CategoryTheory.Factorisation f} (f_1 : X_1 ⟶ Y_1) (g : Y_1 ⟶ Z) {Z_1 : C} (h : Z.mid ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f_1 g).h h =
CategoryTheory.CategoryStruct.comp f_1.h (C... | null | true |
AddCommGroup.intIsScalarTower | Mathlib.Algebra.Module.NatInt | ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower ℤ R M | null | true |
Mathlib.Tactic.ClickSuggestions.GrwKey._sizeOf_inst | Mathlib.Tactic.ClickSuggestions.GRewrite | SizeOf Mathlib.Tactic.ClickSuggestions.GrwKey | null | false |
_private.Mathlib.Analysis.Normed.Module.Multilinear.Basic.0.MultilinearMap.continuous_of_bound._simp_1_1 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True | null | false |
StateTransition.tr_eval_rev | Mathlib.Computability.StateTransition | ∀ {σ₁ : Type u_1} {σ₂ : Type u_2} {f₁ : σ₁ → Option σ₁} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂ → Prop},
StateTransition.Respects f₁ f₂ tr →
∀ {a₁ : σ₁} {b₂ a₂ : σ₂},
tr a₁ a₂ → b₂ ∈ StateTransition.eval f₂ a₂ → ∃ b₁, tr b₁ b₂ ∧ b₁ ∈ StateTransition.eval f₁ a₁ | null | true |
StarSubalgebra.ext_iff | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] {S T : StarSubalgebra R A},
S = T ↔ ∀ (x : A), x ∈ S ↔ x ∈ T | null | true |
Std.Time.DateFormatSymbols.mk.inj | Std.Time.Format.DateFormat | ∀ {monthLong monthShort monthNarrow : Vector String 12}
{weekdayLong weekdayShort weekdayNarrow weekdayTwoLetter : Vector String 7}
{eraShort eraLong eraNarrow : Vector String 2} {quarterShort quarterLong quarterNarrow : Vector String 4}
{amShort pmShort amLong pmLong amNarrow pmNarrow : String}
{dayPeriodShort... | null | true |
Set.infs_assoc | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeInf α] (s t u : Set α), s ⊼ t ⊼ u = s ⊼ (t ⊼ u) | null | true |
Filter.cocardinal_aleph0_eq_cofinite | Mathlib.Order.Filter.Cocardinal | ∀ {α : Type u}, Filter.cocardinal α Cardinal.isRegular_aleph0 = Filter.cofinite | null | true |
Sbtw.left_ne_right | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {x y z : P}, Sbtw R x y z → x ≠ z | null | true |
Lean.Lsp.ParameterInformation._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.ParameterInformation | null | false |
_private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.iSup_genWeightSpace_eq_top._simp_1_1 | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), (N = N') = (↑N = ↑N') | null | false |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.instFaithfulSMulSubtypeMemSubalgebraSubalgebra._proof_1 | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ (R : Type u_2) [inst : CommRing R] {A : Type u_1} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra A B] (D : Algebra.Smooth.DescentAux✝ A B),
FaithfulSMul (↥(Algebra.Smooth.DescentAux.subalgebra✝ R D)) A | null | false |
_private.Mathlib.Order.Atoms.0.IsAtom.Iic.match_1_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : Preorder α] {a x : α} (hax : a ≤ x)
(motive : (x_1 : { x_1 // x_1 ∈ Set.Iic x }) → x_1 < ⟨a, hax⟩ → Prop) (x_1 : { x_1 // x_1 ∈ Set.Iic x })
(hba : x_1 < ⟨a, hax⟩),
(∀ (b : α) (property : b ∈ Set.Iic x) (hba : ⟨b, property⟩ < ⟨a, hax⟩), motive ⟨b, property⟩ hba) → motive x_1 hba | null | false |
CategoryTheory.Under.mapCongr._proof_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} T] {X Y : T} (f g : X ⟶ Y),
f = g → ∀ (A : CategoryTheory.Under Y), (CategoryTheory.Under.map f).obj A = (CategoryTheory.Under.map g).obj A | null | false |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.BoundedVariationOn.of_finset._proof_1_11 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} (s : Finset α) (hne : s.Nonempty) (this : 0 < s.card) (x x_1 : ℕ),
x ≤ x_1 → ⟨min x (s.card - 1), ⋯⟩ ≤ ⟨min x_1 (s.card - 1), ⋯⟩ | null | false |
PresheafOfModules.instModuleCarrierStalkCommRingCatCarrierAbPresheafOpensCarrier._proof_1 | Mathlib.Algebra.Category.ModuleCat.Stalk | ∀ {X : TopCat} {R : TopCat.Presheaf CommRingCat X}
(M : PresheafOfModules (CategoryTheory.Functor.comp R (CategoryTheory.forget₂ CommRingCat RingCat))) (x : ↑X)
{i j : (TopologicalSpace.OpenNhds x)ᵒᵖ} (f : i ⟶ j)
(r :
↑(((TopologicalSpace.OpenNhds.inclusion x).op.comp
(CategoryTheory.Functor.comp ... | null | false |
_private.Mathlib.Data.Finset.Basic.0.Equiv.Finset.union_symm_right._simp_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (e.symm x = y) = (x = e y) | null | false |
_private.Mathlib.MeasureTheory.Measure.Hausdorff.0.Isometry.hausdorffMeasure_image._simp_1_2 | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] (m : ENNReal → ENNReal),
⇑(MeasureTheory.Measure.mkMetric m) = ⇑(MeasureTheory.OuterMeasure.mkMetric m) | null | false |
instLawfulMonadTacticM_batteries | Batteries.Lean.LawfulMonad | LawfulMonad Lean.Elab.Tactic.TacticM | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go_get_aux._proof_1_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var | ∀ {w : ℕ}, ∀ curr ≤ w, ∀ (idx : ℕ), ¬curr < w → ¬curr = w → False | null | false |
Lex.instSemifield._proof_1 | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : Semifield K],
autoParam (∀ (a b : Lex K), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam | null | false |
Std.TreeSet.Raw.getD_minD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = false → ∀ {fallback fallback' : α}, t.getD (t.minD fallback) fallback' = t.minD fallback | null | true |
commGroupOfIsUnit | Mathlib.Algebra.Group.Units.Defs | {M : Type u_1} → [hM : CommMonoid M] → (∀ (a : M), IsUnit a) → CommGroup M | Constructs a `CommGroup` structure on a `CommMonoid` consisting only of units. | true |
TopologicalSpace.Opens.map_comp_obj' | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : Set ↑Z) (p : IsOpen U),
(TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.comp f g)).obj { carrier := U, is_open' := p } =
(TopologicalSpace.Opens.map f).obj ((TopologicalSpace.Opens.map g).obj { carrier := U, is_open' := p }) | null | true |
CategoryTheory.Limits.CatCospanTransformMorphism.whiskerLeft_base | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {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 : Categ... | null | true |
_private.Mathlib.Algebra.Category.AlgCat.FilteredColimits.0.AlgCat.isColimitCoconeOfIsFiltered._proof_2 | Mathlib.Algebra.Category.AlgCat.FilteredColimits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
{F : CategoryTheory.Functor J (AlgCat R)}
[inst_2 : CategoryTheory.Limits.PreservesColimitsOfShape J (CategoryTheory.forget RingCat)]
{c : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.forget₂ (AlgCat R) Rin... | null | false |
BitVec.extractLsb'_append_eq_of_le | Init.Data.BitVec.Lemmas | ∀ {v w : ℕ} {xhi : BitVec v} {xlo : BitVec w} {start len : ℕ},
w ≤ start → BitVec.extractLsb' start len (xhi ++ xlo) = BitVec.extractLsb' (start - w) len xhi | Extracting bits `[start..start+len)` from `(xhi ++ xlo)` equals extracting
the bits from `xhi` when `start` is outside `xlo`.
| true |
_private.Lean.Meta.Tactic.Repeat.0.Lean.Meta.repeat'Core.go.match_3 | Lean.Meta.Tactic.Repeat | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n | null | false |
UInt16.toUSize_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a <<< b).toUSize = a.toUSize <<< (b % 16).toUSize % 65536 | null | true |
_private.Mathlib.MeasureTheory.OuterMeasure.AE.0.MeasureTheory.union_ae_eq_right._simp_1_2 | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, (s ≤ᵐ[μ] t) = (μ (s \ t) = 0) | null | false |
_private.Init.Data.Array.Lemmas.0.Array.back_append._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {l : List α}, (l.isEmpty = true) = (l = []) | null | false |
Function.Even | Mathlib.Algebra.Group.EvenFunction | {α : Type u_1} → {β : Type u_2} → [Neg α] → (α → β) → Prop | A function `f` is _even_ if it satisfies `f (-x) = f x` for all `x`. | true |
Mathlib.Meta.NormNum.IsNNRat.to_isRat | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : Ring α] {a : α} {n d : ℕ},
Mathlib.Meta.NormNum.IsNNRat a n d → Mathlib.Meta.NormNum.IsRat a (Int.ofNat n) d | null | true |
Aesop.aesop.dev.generateScript | Aesop.Options.Public | Lean.Option Bool | (aesop) Only for use by Aesop developers. Generates a script even if none was requested.
| true |
Lean.Lsp.VersionedTextDocumentIdentifier.casesOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.VersionedTextDocumentIdentifier → Sort u} →
(t : Lean.Lsp.VersionedTextDocumentIdentifier) →
((uri : Lean.Lsp.DocumentUri) → (version? : Option ℕ) → motive { uri := uri, version? := version? }) → motive t | null | false |
_private.Mathlib.Data.Set.Lattice.Image.0.Set.iUnion_prod_of_monotone._simp_1_4 | Mathlib.Data.Set.Lattice.Image | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
CategoryTheory.Limits.WalkingParallelFamily.equivalenceOfEquiv | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{J' : Type w'} →
J ≃ J' → (CategoryTheory.Limits.WalkingParallelFamily J ≌ CategoryTheory.Limits.WalkingParallelFamily J') | A bijection between types gives an equivalence between `WalkingParallelFamily` categories. | true |
UniformSpace.Completion.completeSpace | Mathlib.Topology.UniformSpace.Completion | ∀ (α : Type u_1) [inst : UniformSpace α], CompleteSpace (UniformSpace.Completion α) | null | true |
Nat.stirlingSecond._sunfold | Mathlib.Combinatorics.Enumerative.Stirling | ℕ → ℕ → ℕ | null | false |
smoothPresheafCommGroup._proof_2 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {EM : Type u_3} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_4} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_5} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_6} [inst_6 : Topo... | null | false |
SSet.PtSimplex.MulStruct.unop_map | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g fg : X.PtSimplex n x} {i : Fin n}
(h : g.op.MulStruct f.op fg.op i) {j : Fin n} (hij : autoParam (i.rev = j) SSet.PtSimplex.MulStruct.unop._auto_1),
(h.unop hij).map = SSet.yonedaEquiv.symm (SSet.opObjEquiv (SSet.yonedaEquiv h.map)) | null | true |
PEquiv.injective_of_forall_ne_isSome | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} (f : α ≃. β) (a₂ : α), (∀ (a₁ : α), a₁ ≠ a₂ → (f a₁).isSome = true) → Function.Injective ⇑f | If the domain of a `PEquiv` is `α` except a point, its forward direction is injective. | true |
Sum.Ioo_inr_inr | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (b₁ b₂ : β),
Finset.Ioo (Sum.inr b₁) (Sum.inr b₂) = Finset.map Function.Embedding.inr (Finset.Ioo b₁ b₂) | null | true |
AffineIsometryEquiv.toAffineIsometry | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_5} →
{P : Type u_10} →
{P₂ : Type u_11} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[inst_2 : NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[inst_4 : Nor... | Reinterpret an `AffineIsometryEquiv` as an `AffineIsometry`. | true |
Lean.Elab.Tactic.withCaseRef | Lean.Elab.Tactic.Basic | {m : Type → Type} → {α : Type} → [Monad m] → [Lean.MonadRef m] → Lean.Syntax → Lean.Syntax → m α → m α | Use position of `=> $body` for error messages.
If there is a line break before `body`, the message will be displayed on `=>` only,
but the "full range" for the info view will still include `body`. | true |
CStarMatrix.mapₗ | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {m : Type u_1} →
{n : Type u_2} →
{R : Type u_3} →
{S : Type u_4} →
{A : Type u_5} →
{B : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
{σ : R →+* S} →
[inst_2 : AddCommMonoid A] →
[inst_3 : AddComm... | The semilinear map constructed by applying a semilinear map to all the entries of the matrix. | true |
_private.Init.Data.List.SplitOn.Lemmas.0.List.splitOnPPrepend.eq_2 | Init.Data.List.SplitOn.Lemmas | ∀ {α : Type u_1} (p : α → Bool) (x : List α) (a : α) (t : List α),
List.splitOnPPrepend p (a :: t) x =
if p a = true then x.reverse :: List.splitOnPPrepend p t [] else List.splitOnPPrepend p t (a :: x) | null | true |
CompleteLattice.MulticoequalizerDiagram.multispanIndex._proof_8 | Mathlib.Order.CompleteLattice.MulticoequalizerDiagram | ∀ {T : Type u_1} [inst : CompleteLattice T] {ι : Type u_2} {x : T} {u : ι → T} {v : ι → ι → T},
CompleteLattice.MulticoequalizerDiagram x u v →
∀ (x : (CategoryTheory.Limits.MultispanShape.prod ι).L),
(match x with
| (i, j) => v i j) ≤
u ((CategoryTheory.Limits.MultispanShape.prod ι).snd x) | null | false |
HasLineDerivWithinAt.mono | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {f' : F}
{s t : Set E} {x v : E}, HasLineDerivWithinAt 𝕜 f f' s x v → t ⊆ s → HasLineDerivWithinAt 𝕜 f f' t x... | null | true |
CategoryTheory.Limits.IsColimit.natIso | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cocone F} →
CategoryTheory.Limits.IsColimit t →
((CategoryTheory.coyoneda.ob... | The colimit of `F` represents the functor taking `W` to
the set of cocones on `F` with cone point `W`. | true |
LinearMap.equivOfDetNeZero._proof_3 | Mathlib.LinearAlgebra.Determinant | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module 𝕜 M], SMulCommClass 𝕜 𝕜 M | null | false |
Lean.Meta.Simp.Arith.Nat.ToLinear.State.mk.injEq | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | ∀ (varMap : Lean.Meta.KExprMap ℕ) (vars : Array Lean.Expr) (varMap_1 : Lean.Meta.KExprMap ℕ) (vars_1 : Array Lean.Expr),
({ varMap := varMap, vars := vars } = { varMap := varMap_1, vars := vars_1 }) = (varMap = varMap_1 ∧ vars = vars_1) | null | true |
Equiv.subtypeSubtypeEquivSubtype_apply_coe | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_8} {p q : α → Prop} (h : ∀ {x : α}, q x → p x) (a : { x // q ↑x }),
↑((Equiv.subtypeSubtypeEquivSubtype h) a) = ↑↑a | null | true |
Subtype.val_prop | Mathlib.Data.Subtype | ∀ {α : Type u_1} {S : Set α} (a : { a // a ∈ S }), ↑a ∈ S | null | true |
CategoryTheory.ObjectProperty.productToFamily | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(P : CategoryTheory.ObjectProperty C) → (X : C) → CategoryTheory.StructuredArrow X P.ι → C | Given `P : ObjectProperty C` and `X : C`, this is the map which
sends `i : StructuredArrow P.ι X` to `i.right.obj : C`. The product
of this family is the target of the morphism `P.productTo X`. | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_2 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} {g : Equiv.Perm α} {a : α}, [a, g a, g (g a)].Nodup → ¬g a = a | null | false |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.initFn._@.Mathlib.Tactic.Linter.TextBased.1476535223._hygCtx._hyg.4 | Mathlib.Tactic.Linter.TextBased | IO (Lean.Option Bool) | null | false |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData_π | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {... | null | true |
String.Slice.Pattern.Model.IsRevMatch.exists_isLongestRevMatch | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsRevMatch pat pos → ∃ pos', String.Slice.Pattern.Model.IsLongestRevMatch pat pos' | null | true |
SubMulAction.ofStabilizer.conjMap | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | {G : Type u_1} →
[inst : Group G] →
{α : Type u_2} →
[inst_1 : MulAction G α] →
{g : G} →
{a b : α} →
(hg : b = g • a) →
↥(SubMulAction.ofStabilizer G a) →ₑ[⇑(MulAction.stabilizerEquivStabilizer hg)]
↥(SubMulAction.ofStabilizer G b) | Conjugation induces an equivariant map between the SubMulAction of
the stabilizer of a point and that of its translate. | true |
inv_lt_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b : α},
a < 0 → b < 0 → (a⁻¹ < b ↔ b⁻¹ < a) | null | true |
_private.Mathlib.RingTheory.Ideal.Lattice.0.Ideal.eq_top_of_isUnit_mem.match_1_1 | Mathlib.RingTheory.Ideal.Lattice | ∀ {α : Type u_1} [inst : Semiring α] {x : α} (motive : (∃ b, b * x = 1) → Prop) (x_1 : ∃ b, b * x = 1),
(∀ (y : α) (hy : y * x = 1), motive ⋯) → motive x_1 | null | false |
AdjoinRoot.isAdjoinRoot._proof_1 | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (f : Polynomial R), RingHom.ker (AdjoinRoot.mkₐ f) = Ideal.span {f} | null | false |
CategoryTheory.Bicategory.rightAdjointSquareConjugate.vcomp | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c d : B} →
{g : a ⟶ c} →
{h : b ⟶ d} →
{r₁ : b ⟶ a} →
{r₂ r₃ : d ⟶ c} →
(CategoryTheory.CategoryStruct.comp r₁ g ⟶ CategoryTheory.CategoryStruct.comp h r₂) →
(r₂ ⟶ r₃) → (CategoryTheory.Cat... | Composition of a square between right adjoints with a conjugate square. | true |
AddGroupCone.nonneg_toAddSubmonoid | Mathlib.Algebra.Order.Group.Cone | ∀ {H : Type u_1} [inst : AddCommGroup H] [inst_1 : PartialOrder H] [inst_2 : IsOrderedAddMonoid H],
(AddGroupCone.nonneg H).toAddSubmonoid = AddSubmonoid.nonneg H | null | true |
GenContFract.Pair.noConfusion | Mathlib.Algebra.ContinuedFractions.Basic | {P : Sort u} →
{α : Type u_1} →
{t : GenContFract.Pair α} →
{α' : Type u_1} → {t' : GenContFract.Pair α'} → α = α' → t ≍ t' → GenContFract.Pair.noConfusionType P t t' | null | false |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.Basic.0.MeasureTheory.eLpNorm_const._simp_1_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{b : β}, MeasureTheory.AEStronglyMeasurable (fun x => b) μ = True | null | false |
_private.Mathlib.Tactic.WithoutCDot.0.Lean.Elab.Term.withoutCDotContents.parenthesizer | Mathlib.Tactic.WithoutCDot | Lean.PrettyPrinter.Parenthesizer | null | true |
Int.preimage_Ioo | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] {a b : R},
Int.cast ⁻¹' Set.Ioo a b = Set.Ioo ⌊a⌋ ⌈b⌉ | null | true |
_private.Mathlib.Data.Set.Subsingleton.0.Set.nontrivial_coe_sort._simp_1_1 | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u}, Nontrivial α = Set.univ.Nontrivial | null | false |
Filter.filter_eq_iff | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f g : Filter α}, f = g ↔ f.sets = g.sets | null | true |
Hyperreal.archimedeanClassMk_nonneg_of_tendsto | Mathlib.Analysis.Real.Hyperreal | ∀ {x : ℝ*} {r : ℝ}, Filter.Germ.Tendsto x (nhds r) → 0 ≤ ArchimedeanClass.mk x | null | true |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.isOpen_iff_of_mem._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClosed sᶜ = IsOpen s | null | false |
Real.Angle.sign | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | Real.Angle → SignType | The sign of a `Real.Angle` is `0` if the angle is `0` or `π`, `1` if the angle is strictly
between `0` and `π` and `-1` is the angle is strictly between `-π` and `0`. It is defined as the
sign of the sine of the angle. | true |
Lean.ScopedEnvExtension.Descr._sizeOf_1 | Lean.ScopedEnvExtension | {α β σ : Type} → [SizeOf α] → [SizeOf β] → [SizeOf σ] → Lean.ScopedEnvExtension.Descr α β σ → ℕ | null | false |
continuousOn_const_smul_iff₀ | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} {β : Type u_3} {G₀ : Type u_4} [inst : TopologicalSpace α] [inst_1 : GroupWithZero G₀]
[inst_2 : MulAction G₀ α] [ContinuousConstSMul G₀ α] [inst_4 : TopologicalSpace β] {f : β → α} {c : G₀} {s : Set β},
c ≠ 0 → (ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.