name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Aesop.PremiseIndex._sizeOf_inst | Aesop.Forward.PremiseIndex | SizeOf Aesop.PremiseIndex | null | false |
ModuleCat.exteriorPower.functor | Mathlib.Algebra.Category.ModuleCat.ExteriorPower | (R : Type u) → [inst : CommRing R] → ℕ → CategoryTheory.Functor (ModuleCat R) (ModuleCat R) | The functor `ModuleCat R ⥤ ModuleCat R` which sends a module to its
`n`th exterior power. | true |
sSupIndep_iff | Mathlib.Order.SupIndep | ∀ {α : Type u_5} [inst : CompleteLattice α] (s : Set α), sSupIndep s ↔ iSupIndep Subtype.val | null | true |
Aesop.GoalState.ctorIdx | Aesop.Tree.Data | Aesop.GoalState → ℕ | null | false |
unexpandMkArray0 | Init.NotationExtra | Lean.PrettyPrinter.Unexpander | null | true |
Lean.Elab.Tactic.evalWithReducible | Lean.Elab.Tactic.ElabTerm | Lean.Elab.Tactic.Tactic | null | true |
ZeroAtInftyContinuousMap.unitizationRingEquiv | Mathlib.Topology.ContinuousMap.ZeroAtInftyUnitization | (X : Type u_1) →
(R : Type u_2) →
[inst : TopologicalSpace X] →
[R1Space X] →
[inst_2 : TopologicalSpace R] →
[inst_3 : CommRing R] →
[inst_4 : IsTopologicalRing R] → Unitization R (ZeroAtInftyContinuousMap X R) ≃+* C(OnePoint X, R) | `ZeroAtInftyContinuousMap.unitizationEquiv` as a `RingEquiv`. | true |
Submonoid.mem_closure_pair | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {A : Type u_4} [inst : CommMonoid A] (a b c : A), c ∈ Submonoid.closure {a, b} ↔ ∃ m n, a ^ m * b ^ n = c | An element is in the closure of a two-element set if it is a linear combination of those two
elements. | true |
BooleanRing.sup_comm | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (a b : α), a ⊔ b = b ⊔ a | null | true |
CategoryTheory.SmallObject.functorMapTgt.eq_1 | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i)
{S T X Y : C} {πX : X ⟶ S} {πY : Y ⟶ T} (τ : CategoryTheory.Arrow.mk πX ⟶ CategoryTheory.Arrow.mk πY)
[inst_1 :
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObj... | null | true |
IsLocalDiffeomorphAt.mfderivToContinuousLinearEquiv._proof_2 | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H₁ : Type u_4}
[inst_5 : TopologicalSpace H₁] {H₂ : Type u_6} [inst_6 : TopologicalSpace H₂] {I : ModelWithCorn... | null | false |
Action.Functor.mapActionPreservesLimitsOfShapeOfPreserves | Mathlib.CategoryTheory.Action.Limits | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {W : Type u_3}
[inst_1 : CategoryTheory.Category.{v_2, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [inst_2 : Monoid G]
{J : Type u_5} [inst_3 : CategoryTheory.Category.{v_3, u_5} J] [CategoryTheory.Limits.PreservesLimitsOfShape J F]
[Categ... | `F.mapAction : Action V G ⥤ Action W G` preserves limits of some shape `J` if
`V` has limits of shape `J` and `F` preserves limits of shape `J`. | true |
Lean.Compiler.InlineAttributeKind.alwaysInline.sizeOf_spec | Lean.Compiler.InlineAttrs | sizeOf Lean.Compiler.InlineAttributeKind.alwaysInline = 1 | null | true |
AddSubgroup.normalizer_addCommutator_ge_right | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (H₁ H₂ : AddSubgroup G), H₂ ≤ AddSubgroup.normalizer ↑⁅H₁, H₂⁆ | null | true |
Topology.IsCoinducing.continuous | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
Topology.IsCoinducing f → Continuous f | null | true |
partialFunToPointed._proof_4 | Mathlib.CategoryTheory.Category.PartialFun | ∀ (X : PartialFun),
Option.elim' none (fun a => (CategoryTheory.CategoryStruct.id X a).toOption) { X := Option X, point := none }.point =
Option.elim' none (fun a => (CategoryTheory.CategoryStruct.id X a).toOption) { X := Option X, point := none }.point | null | false |
NatPow.casesOn | Init.Prelude | {α : Type u} → {motive : NatPow α → Sort u_1} → (t : NatPow α) → ((pow : α → ℕ → α) → motive { pow := pow }) → motive t | null | false |
Std.DHashMap.Const.mem_unitOfList._simp_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List α} {k : α},
(k ∈ Std.DHashMap.Const.unitOfList l) = (l.contains k = true) | null | false |
CategoryTheory.Bicategory.eqToHom_whiskerRight | Mathlib.CategoryTheory.Bicategory.Strict.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g : a ⟶ b} (η : f = g) (h : b ⟶ c),
CategoryTheory.Bicategory.whiskerRight (CategoryTheory.eqToHom η) h = CategoryTheory.eqToHom ⋯ | null | true |
Filter.Germ.instLinearOrder | Mathlib.Order.Filter.FilterProduct | {α : Type u} → {β : Type v} → {φ : Ultrafilter α} → [LinearOrder β] → LinearOrder ((↑φ).Germ β) | If `φ` is an ultrafilter then the ultraproduct is a linear order. | true |
Array.mapFinIdxMUnsafe | Init.Data.Array.Basic | {α : Type u} →
{β : Type v} → {m : Type v → Type w} → [Monad m] → (as : Array α) → ((i : ℕ) → α → i < as.size → m β) → m (Array β) | See comment at `forIn'Unsafe`. This mirrors `mapMUnsafe`, threading the index `i`
and supplying the in-bounds proof via `lcProof`. | true |
AsBoolAlg | Mathlib.Algebra.Ring.BooleanRing | Type u_4 → Type u_4 | Type synonym to view a Boolean ring as a Boolean algebra. | true |
_private.Mathlib.Topology.Sheaves.Flasque.0.TopCat.Sheaf.IsFlasque.epi_of_shortExact.match_1_7.eq_2 | Mathlib.Topology.Sheaves.Flasque | ∀ (motive : Fin 2 → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1),
(match 1 with
| 0 => h_1 ()
| 1 => h_2 ()) =
h_2 () | null | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.instHashablePurity.hash.match_1 | Lean.Compiler.LCNF.Basic | (motive : Lean.Compiler.LCNF.Purity → Sort u_1) →
(x : Lean.Compiler.LCNF.Purity) →
(Unit → motive Lean.Compiler.LCNF.Purity.pure) → (Unit → motive Lean.Compiler.LCNF.Purity.impure) → motive x | null | false |
isClopen_range_inr | Mathlib.Topology.Clopen | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], IsClopen (Set.range Sum.inr) | null | true |
Set.Nontrivial.not_subsingleton | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u} {s : Set α}, s.Nontrivial → ¬s.Subsingleton | **Alias** of the reverse direction of `Set.not_subsingleton_iff`. | true |
Computation.Results.terminates | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {s : Computation α} {a : α} {n : ℕ}, s.Results a n → s.Terminates | null | true |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.muFun._unsafe_rec | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | (𝕜 : Type u_1) →
{α : Type u_4} →
[AddCommGroup 𝕜] → [One 𝕜] → [inst : Preorder α] → [LocallyFiniteOrder α] → [DecidableEq α] → α → α → 𝕜 | null | false |
CategoryTheory.Abelian.SpectralObject.fromOpcycles_δ_assoc | 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 l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (f₂₃ : j ⟶ l)
(h₂₃ : CategoryTheory.CategoryStruct.... | null | true |
Finset.union_val_nd | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), (s ∪ t).val = s.val.ndunion t.val | null | true |
AddCommute.zsmul_add | Mathlib.Algebra.Group.Commute.Defs | ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a b : G}, AddCommute a b → ∀ (n : ℤ), n • (a + b) = n • a + n • b | null | true |
Lean.Compiler.LCNF.inScope | Lean.Compiler.LCNF.MonadScope | {m : Type → Type} → [Lean.Compiler.LCNF.MonadScope m] → [Monad m] → Lean.FVarId → m Bool | null | true |
HasStrictFDerivAt.cpow | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f g : E → ℂ} {f' g' : StrongDual ℂ E}
{x : E},
HasStrictFDerivAt f f' x →
HasStrictFDerivAt g g' x →
f x ∈ Complex.slitPlane →
HasStrictFDerivAt (fun x => f x ^ g x) ((g x * f x ^ (g x - 1)) • f' + (f x ^ g x * Complex.log ... | null | true |
TopCat.Presheaf.pushforwardEq_hom_app._proof_2 | Mathlib.Topology.Sheaves.Presheaf | ∀ {X Y : TopCat} {f g : X ⟶ Y},
f = g →
∀ (U : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
(TopologicalSpace.Opens.map f).op.obj U = (TopologicalSpace.Opens.map g).op.obj U | null | false |
PreconnectedSpace.rec | Mathlib.Topology.Connected.Basic | {α : Type u} →
[inst : TopologicalSpace α] →
{motive : PreconnectedSpace α → Sort u_1} →
((isPreconnected_univ : IsPreconnected Set.univ) → motive ⋯) → (t : PreconnectedSpace α) → motive t | null | false |
Mathlib.Tactic.Sat.Clause.mk.injEq | Mathlib.Tactic.Sat.FromLRAT | ∀ (lits : Array ℤ) (expr proof : Lean.Expr) (lits_1 : Array ℤ) (expr_1 proof_1 : Lean.Expr),
({ lits := lits, expr := expr, proof := proof } = { lits := lits_1, expr := expr_1, proof := proof_1 }) =
(lits = lits_1 ∧ expr = expr_1 ∧ proof = proof_1) | null | true |
Function.Injective.isMulTorsionFree | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Monoid M] [inst_1 : Monoid N] [IsMulTorsionFree N] (f : M →* N),
Function.Injective ⇑f → IsMulTorsionFree M | If the codomain of an injective monoid homomorphism is torsion free,
then so is the domain. | true |
SimpleGraph.edgeSet_sSup | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} {s : Set (SimpleGraph V)}, (sSup s).edgeSet = ⋃₀ (SimpleGraph.edgeSet '' s) | null | true |
HomogeneousLocalization.NumDenSameDeg.instNeg._proof_1 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_3} {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [NegMemClass σ A] {𝒜 : ι → σ}
(x : Submonoid A) (c : HomogeneousLocalization.NumDenSameDeg 𝒜 x), -↑c.num ∈ 𝒜 c.deg | null | false |
CategoryTheory.Adjunction.coconesIsoComponentInv._proof_1 | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {J : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} J] {K : CategoryTheory.Functor J C} (Y : D)
(t :... | null | false |
Function.RightInverse.filter_map | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α},
Function.RightInverse g f → Function.RightInverse (Filter.map g) (Filter.map f) | null | true |
GradedRingHom.coe_mul | Mathlib.RingTheory.GradedAlgebra.RingHom | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_6} [inst : Semiring A] [inst_1 : SetLike σ A] {𝒜 : ι → σ} (f g : 𝒜 →+*ᵍ 𝒜),
⇑(f * g) = ⇑f ∘ ⇑g | null | true |
Submodule.toAddSubmonoid_injective | Mathlib.Algebra.Module.Submodule.Defs | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
Function.Injective Submodule.toAddSubmonoid | null | true |
CochainComplex.πTruncGE_naturality_assoc | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : ∀ (i : ℤ), HomologicalComplex.HasHomology K i] [inst_4 : ∀ (i : ℤ), HomologicalComplex.HasHomology L i]... | null | true |
List.sublists'.eq_1 | Mathlib.Data.List.Sublists | ∀ {α : Type u_1} (l : List α),
l.sublists' = (List.foldr (fun a arr => Array.foldl (fun r l => r.push (a :: l)) arr arr) #[[]] l).toList | null | true |
Measurable.sinh | Mathlib.MeasureTheory.Function.SpecialFunctions.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → ℝ}, Measurable f → Measurable fun x => Real.sinh (f x) | null | true |
fst_himp | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : HImp α] [inst_1 : HImp β] (a b : α × β), (a ⇨ b).1 = a.1 ⇨ b.1 | null | true |
NonemptyInterval.instPreorder._proof_3 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Preorder α],
autoParam (∀ (a b : NonemptyInterval α), a < b ↔ a ≤ b ∧ ¬b ≤ a) Preorder.lt_iff_le_not_ge._autoParam | null | false |
_private.Lean.Data.Lsp.Internal.0.Lean.Lsp.instOrdRefIdent.ord.match_1 | Lean.Data.Lsp.Internal | (motive : Lean.Lsp.RefIdent → Lean.Lsp.RefIdent → Sort u_1) →
(x x_1 : Lean.Lsp.RefIdent) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.const a a_1) (Lean.Lsp.RefIdent.const b b_1)) →
((a a_1 : String) → (x : Lean.Lsp.RefIdent) → motive (Lean.Lsp.RefIdent.const a a_1) x) →
((x : Lean.Lsp.Ref... | null | false |
Nat.mod_four_ne_three_of_mem_primeFactors_of_isSquare_neg_one | Mathlib.NumberTheory.SumTwoSquares | ∀ {p n : ℕ}, p ∈ n.primeFactors → IsSquare (-1) → p % 4 ≠ 3 | If `p` is a prime factor of `n` such that `-1` is a square modulo `n`, then `p % 4 ≠ 3`. | true |
IsAddUnit.add_neg_cancel_left | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : SubtractionMonoid α] {a : α}, IsAddUnit a → ∀ (b : α), a + (-a + b) = b | null | true |
IO.instReprTaskState.repr | Init.System.IO | IO.TaskState → ℕ → Std.Format | null | true |
Real.Angle.cos_eq_iff_eq_or_eq_neg | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ ψ : Real.Angle}, θ.cos = ψ.cos ↔ θ = ψ ∨ θ = -ψ | null | true |
BitVec.reverse_append._proof_2 | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ}, v + w = w + v | null | false |
Std.ExtDHashMap.mem_insert | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β k}, a ∈ m.insert k v ↔ (k == a) = true ∨ a ∈ m | null | true |
AddValuation.comap_comp | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{S₁ : Type u_6} {S₂ : Type u_7} [inst_2 : Ring S₁] [inst_3 : Ring S₂] (f : S₁ →+* S₂) (g : S₂ →+* R),
AddValuation.comap (g.comp f) v = AddValuation.comap f (AddValuation.comap g v) | null | true |
QuadraticAlgebra.imₗ._proof_2 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} (a b : R) [inst : Semiring R] (x : R) (x_1 : QuadraticAlgebra R a b), (x • x_1).im = (x • x_1).im | null | false |
_private.Init.Data.Range.Polymorphic.PRange.0.Std.instDecidableEqRoi.decEq._proof_2 | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u_1} (a b : α), ¬a = b → a<...* = b<...* → False | null | false |
_private.Mathlib.LinearAlgebra.UnitaryGroup.0.Matrix.kroneckerTMul_mem_unitary._simp_1_1 | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, (U ∈ unitary R) = (star U * U = 1 ∧ U * star U = 1) | null | false |
BitVec.instOrOp | Init.Data.BitVec.Basic | {w : ℕ} → OrOp (BitVec w) | null | true |
Representation.IntertwiningMap.instSMulInt | Mathlib.RepresentationTheory.Intertwining | {A : Type u_1} →
{G : Type u_2} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
{V : Type u_6} →
{W : Type u_7} →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommGroup W] →
[inst_4 : Module A V] →
[inst_5 : Module A W] →
... | null | true |
Lean.Grind.AC.Seq.beq'_eq | Init.Grind.AC | ∀ (s₁ s₂ : Lean.Grind.AC.Seq), (s₁.beq' s₂ = true) = (s₁ = s₂) | null | true |
UniqueMul.of_mulHom_image | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Mul G] [inst_1 : Mul H] {A B : Finset G} {a0 b0 : G} [inst_2 : DecidableEq H]
(f : G →ₙ* H),
(∀ ⦃a b c d : G⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d) →
UniqueMul (Finset.image (⇑f) A) (Finset.image (⇑f) B) (f a0) (f b0) → UniqueMul A B a0 b0 | null | true |
Std.Tactic.BVDecide.Frontend.Normalize.BitVec.add_left_inj | Std.Tactic.BVDecide.Normalize.Equal | ∀ {w : ℕ} (a b c : BitVec w), (a + c == b + c) = (a == b) | null | true |
Std.DHashMap.Const.getKeyD_insertMany_list_of_mem | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {l : List (α × β)} {k k' fallback : α},
(k == k') = true →
List.Pairwise (fun a b => (a.1 == b.1) = false) l →
k ∈ List.map Prod.fst l → (Std.DHashMap.Const.insertMany m l).getKeyD k'... | null | true |
List.toList_mkSlice_roi | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {lo : ℕ},
Std.Slice.toList (Std.Roi.Sliceable.mkSlice xs (lo<...*)) = List.drop (lo + 1) xs | null | true |
_private.Mathlib.Control.Monad.Cont.0.ExceptT.run_bind.match_1.splitter | Mathlib.Control.Monad.Cont | {ε α : Type u_1} →
(motive : Except ε α → Sort u_2) →
(x : Except ε α) → ((x : α) → motive (Except.ok x)) → ((e : ε) → motive (Except.error e)) → motive x | null | true |
Subgroup.widthInfty | Mathlib.NumberTheory.ModularForms.Cusps | Subgroup (GL (Fin 2) ℝ) → ℝ | The width of the cusp `∞`, i.e. the `x` such that `𝒢.periods = zmultiples x`, or 0 if no such
`x` exists. | true |
Lean.Elab.WF.mkWfParam | Lean.Elab.PreDefinition.WF.Preprocess | Lean.Expr → Lean.MetaM Lean.Expr | null | true |
Char.minSurrogate | Batteries.Data.Char.Basic | ℕ | Minimum surrogate code point.
(See [unicode scalar value](https://www.unicode.org/glossary/#unicode_scalar_value).)
| true |
FGAlgCat.uliftFunctor._proof_3 | Mathlib.Algebra.Category.CommAlgCat.FiniteType | ∀ (R : Type u_1) [inst : CommRing R] (A : FGAlgCat R), Algebra.FiniteType R ↑↧(ULift.{u_3, u_2} ↑A.obj) | null | false |
AddSubmonoid.LocalizationMap.map_comp_map | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N] {P : Type u_3}
[inst_2 : AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : ↥S), g ↑y ∈ T)
{Q : Type u_4} [inst_3 : AddCommMonoid Q] {k : T.LocalizationMap Q} {A : Type u_5... | If `AddCommMonoid` homs `g : M →+ P, l : P →+ A` induce maps of localizations, the composition
of the induced maps equals the map of localizations induced by `l ∘ g`. | true |
CategoryTheory.shiftFunctorZero_hom_app_shift | Mathlib.CategoryTheory.Shift.Basic | ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddCommMonoid A]
[inst_2 : CategoryTheory.HasShift C A] {X : C} (n : A),
(CategoryTheory.shiftFunctorZero C A).hom.app ((CategoryTheory.shiftFunctor C n).obj X) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorCom... | null | true |
Lean.Lsp.LeanDidOpenTextDocumentParams.toDidOpenTextDocumentParams | Lean.Data.Lsp.Extra | Lean.Lsp.LeanDidOpenTextDocumentParams → Lean.Lsp.DidOpenTextDocumentParams | null | true |
Filter.EventuallyEqSet.countable_iInter | Mathlib.Order.Filter.CountableInter | ∀ {ι : Sort u_1} {α : Type u_2} {l : Filter α} [CountableInterFilter l] [Countable ι] {s t : ι → Set α},
(∀ (i : ι), s i =ᶠ[l] t i) → ⋂ i, s i =ᶠ[l] ⋂ i, t i | null | true |
Float.Model.UnpackedFloat.ofUInt16 | Init.Data.Float.Model.Unpacked.Operations.OfNat | Float.Model.Format → UInt16 → Float.Model.UnpackedFloat | Converts a `UInt16` to an `UnpackedFloat`, returning positive zero on zero. | true |
Finset.inl_mem_sumLift₂ | Mathlib.Data.Sum.Interval | ∀ {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6}
{f : α₁ → β₁ → Finset γ₁} {g : α₂ → β₂ → Finset γ₂} {a : α₁ ⊕ α₂} {b : β₁ ⊕ β₂} {c₁ : γ₁},
Sum.inl c₁ ∈ Finset.sumLift₂ f g a b ↔ ∃ a₁ b₁, a = Sum.inl a₁ ∧ b = Sum.inl b₁ ∧ c₁ ∈ f a₁ b₁ | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.StructId.0.Lean.Meta.Grind.Arith.Linear.mkNatModuleInst? | Lean.Meta.Tactic.Grind.Arith.Linear.StructId | Lean.Level → Lean.Expr → Lean.Meta.Grind.GoalM (Option Lean.Expr) | null | true |
Set.subset_compl_iff_disjoint_right | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊆ tᶜ ↔ Disjoint s t | null | true |
GroupWithZero.div_eq_mul_inv | Mathlib.Algebra.GroupWithZero.Defs | ∀ {G₀ : Type u} [self : GroupWithZero G₀] (a b : G₀), a / b = a * b⁻¹ | `a / b := a * b⁻¹` | true |
AlgebraicGeometry.Scheme.IsLocallyDirected.tAux._proof_2 | Mathlib.AlgebraicGeometry.Gluing | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AlgebraicGeometry.Scheme)
[inst_1 : ∀ {i j : J} (f : i ⟶ j), AlgebraicGeometry.IsOpenImmersion (F.map f)] (i j : J)
(k :
(AlgebraicGeometry.Scheme.Opens.iSupOpenCover fun k => AlgebraicGeometry.Scheme.Hom.opensRange (F.... | null | false |
_private.Mathlib.NumberTheory.Divisors.0.Int.mem_divisors._simp_1_1 | Mathlib.NumberTheory.Divisors | ∀ {x z : ℤ}, (x ∈ z.divisors) = (x.natAbs ∈ z.natAbs.divisors) | null | false |
_private.Lean.Meta.Sym.Apply.0.Lean.Meta.Sym.BackwardRule.apply'.match_1 | Lean.Meta.Sym.Apply | (motive : Lean.Meta.Sym.ApplyResult → Sort u_1) →
(__x : Lean.Meta.Sym.ApplyResult) →
((mvarIds : List Lean.MVarId) → motive (Lean.Meta.Sym.ApplyResult.goals mvarIds)) →
((x : Lean.Meta.Sym.ApplyResult) → motive x) → motive __x | null | false |
_private.Lean.Meta.FunInfo.0.Lean.Meta.FunInfoEnvCacheKey._sizeOf_inst | Lean.Meta.FunInfo | SizeOf Lean.Meta.FunInfoEnvCacheKey✝ | null | false |
complEDS.eq_1 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u_1} [inst : CommRing R] (b c d : R) (k n : ℤ), complEDS b c d k n = ↑n.sign * complEDS' b c d k n.natAbs | null | true |
FrameHom.copy_eq | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : FrameHom α β) (f' : α → β)
(h : f' = ⇑f), f.copy f' h = f | null | true |
ONote.zero | Mathlib.SetTheory.Ordinal.Notation | ONote | null | true |
Lean.Parser.Tactic._aux_Init_Meta___macroRules_Lean_Parser_Tactic_constructorBang_1 | Init.Meta | Lean.Macro | null | false |
_private.Mathlib.Topology.UniformSpace.AbstractCompletion.0.AbstractCompletion.termι'_2 | Mathlib.Topology.UniformSpace.AbstractCompletion | Lean.ParserDescr | null | true |
Convert.ExpensiveConfig.postTransparency._default | Mathlib.Tactic.Convert | Lean.Meta.TransparencyMode | null | false |
Preorder.noConfusionType | Mathlib.Order.Defs.PartialOrder | Sort u → {α : Type u_2} → Preorder α → {α' : Type u_2} → Preorder α' → Sort u | null | false |
Substring.Raw.ValidFor.startPos | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} {s : Substring.Raw}, Substring.Raw.ValidFor l m r s → s.startPos = { byteIdx := String.utf8Len l } | null | true |
CategoryTheory.Functor.precomposeWhiskerLeftMapCocone_hom_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] {F : CategoryTheory.Functor J C}
{H H' : CategoryTheory.Functor C D} (α : H ≅ H') (c : CategoryTheory.Limits.Cocone F),
(CategoryTheor... | null | true |
Topology.IsInducing.sumElim | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f : X → Z} {g : Y → Z},
Topology.IsInducing f →
Topology.IsInducing g →
Disjoint (closure (Set.range f)) (Set.range g) →
Disjoint (Set.range f) (closure (Set.range g)... | If `f` and `g` are inducing maps whose ranges are separated, then `Sum.elim f g` is inducing. | true |
CategoryTheory.Endofunctor.Coalgebra.isoMk_hom_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
{V₀ V₁ : CategoryTheory.Endofunctor.Coalgebra F} (h : V₀.V ≅ V₁.V)
(w :
autoParam
(CategoryTheory.CategoryStruct.comp V₀.str (F.map h.hom) = CategoryTheory.CategoryStruct.comp h.hom V₁.str)
CategoryTheory.Endof... | null | true |
CategoryTheory.ShortComplex.HomologyData.exact_iff_i_p_zero | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.HomologyData),
S.Exact ↔ CategoryTheory.CategoryStruct.comp h.left.i h.right.p = 0 | null | true |
Std.Http.URI.scheme | Std.Http.Data.URI.Basic | Std.Http.URI → Std.Http.URI.Scheme | The URI scheme (e.g., "http", "https", "ftp").
| true |
Std.Sat.AIG.instDecidableEqDecl.decEq._proof_3 | Std.Sat.AIG.Basic | ∀ {α : Type} (idx : α), ¬Std.Sat.AIG.Decl.false = Std.Sat.AIG.Decl.atom idx | null | false |
List.Ico.filter_le | Mathlib.Data.List.Intervals | ∀ (n m l : ℕ), List.filter (fun x => decide (l ≤ x)) (List.Ico n m) = List.Ico (max n l) m | null | true |
CategoryTheory.ChosenPullbacksAlong.mk | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Y X : C} →
{f : Y ⟶ X} →
(pullback : CategoryTheory.Functor (CategoryTheory.Over X) (CategoryTheory.Over Y)) →
(CategoryTheory.Over.map f ⊣ pullback) → CategoryTheory.ChosenPullbacksAlong f | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.