name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Analysis.Complex.Basic.0.RCLike._aux_Mathlib_Analysis_Complex_Basic___macroRules__private_Mathlib_Analysis_Complex_Basic_0_RCLike_termIC_1 | Mathlib.Analysis.Complex.Basic | Lean.Macro | null | false |
_private.Batteries.Data.Vector.Basic.0.Vector.scanlMFast.loop.eq_def | Batteries.Data.Vector.Basic | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} {n : ℕ} [inst : Monad m] (f : β → α → m β) (as : Vector α n)
(h_su : n < USize.size) (cur : β) (i n_usize : USize) (h_n : n_usize.toNat = n) (h_i : i.toNat ≤ n)
(acc : Vector β i.toNat),
Vector.scanlMFast.loop✝ f as h_su cur i n_usize h_n h_i acc =
if ... | null | true |
DirectSum.map_id | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type u_3} {α : ι → Type u_4} [inst : (i : ι) → AddCommMonoid (α i)],
(DirectSum.map fun i => AddMonoidHom.id (α i)) = AddMonoidHom.id (DirectSum ι fun i => α i) | null | true |
Lean.Meta.DefaultInstances._sizeOf_1 | Lean.Meta.Instances | Lean.Meta.DefaultInstances → ℕ | null | false |
Lean.IO.FS.Stream.readLspRequestAs | Lean.Data.Lsp.Communication | IO.FS.Stream → String → (α : Type) → [Lean.FromJson α] → IO (Lean.JsonRpc.Request α) | null | true |
commAlgCatEquivUnder_unitIso | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ (R : CommRingCat),
(commAlgCatEquivUnder R).unitIso =
CategoryTheory.NatIso.ofComponents
(fun A =>
CommAlgCat.isoMk
(let __RingEquiv := RingEquiv.refl ↑A;
{ toEquiv := __RingEquiv.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ }))
⋯ | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk.inj | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{toLaxFunctor : CategoryTheory.LaxFunctor B C}
{map_id :
autoParam
(∀ (X : B),
toLaxFunctor.map (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (toLaxFunctor.obj X))
... | null | true |
Matroid.IsBasis.isBasis_of_isBasis_of_subset_of_subset | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {I X Y J : Set α}, M.IsBasis I X → M.IsBasis J Y → J ⊆ X → I ⊆ Y → M.IsBasis I Y | null | true |
not_isAddTorsionFree_of_isTorsion | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : AddCommGroup G] [Nontrivial G], IsAddTorsion G → ¬IsAddTorsionFree G | **Alias** of `not_isAddTorsionFree_of_isAddTorsion`.
---
A nontrivial torsion additive abelian group is not torsion-free. | true |
_private.Mathlib.Analysis.Calculus.TangentCone.ProperSpace.0.tangentConeAt_nonempty_of_properSpace._simp_1_4 | Mathlib.Analysis.Calculus.TangentCone.ProperSpace | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) | null | false |
AlgebraicGeometry.PresheafedSpace.map_id_c_app._proof_1 | Mathlib.Geometry.RingedSpace.PresheafedSpace.HasColimits | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor J (AlgebraicGeometry.PresheafedSpace C))
(j : J), CategoryTheory.CategoryStruct.id ↑(F.obj j) = (F.map (CategoryTheory.CategoryStruct.id j)).base | null | false |
IntermediateField.isPurelyInseparable_tower_bot | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) [inst : Field F] (K : Type w) [inst_1 : Field K] [inst_2 : Algebra F K] (M : IntermediateField F K)
[IsPurelyInseparable F K], IsPurelyInseparable F ↥M | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey_eq_iff_getKey?_eq_self_and_forall._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.applyS | Mathlib.Tactic.FBinop | FBinopElab.SRec → Lean.Expr → Lean.Elab.TermElabM (Option Lean.Expr) | Computes `S x := c a1 ... an x` if it is type correct.
Inserts instance arguments after `x`. | true |
Lean.Elab.WF.GuessLex.MutualMeasure.func | Lean.Elab.PreDefinition.WF.GuessLex | ℕ → Lean.Elab.WF.GuessLex.MutualMeasure | The given function index is assigned 1, the rest 0 | true |
Mathlib.Tactic.Peel.throwPeelError | Mathlib.Tactic.Peel | {α : Type} → Lean.Expr → Lean.Expr → Lean.MetaM α | Throws an error saying `ty` and `target` could not be matched up. | true |
CategoryTheory.Functor.postcompose₃_map_app_app_app_app | Mathlib.CategoryTheory.Whiskering | ∀ {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₃] {E : Type u_9}
[inst_3 : CategoryTheory.Category.{v_9, u_9} E] {E' : Type u_10} [inst_4 : CategoryTheory.Category.{v_10, ... | null | true |
List.flatMapM.loop._f | Init.Data.List.Control | {m : Type u → Type v} →
[Monad m] →
{α : Type w} →
{β : Type u} →
(α → m (List β)) →
(x : List α) → List.below (motive := fun x => List (List β) → m (List β)) x → List (List β) → m (List β) | null | false |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Term.syntheticHole._regBuiltin.Lean.Parser.Term.syntheticHole.docString_3 | Lean.Parser.Term.Basic | IO Unit | null | false |
Plausible.SampleableExt.casesOn | Plausible.Sampleable | {α : Sort u} →
{motive : Plausible.SampleableExt α → Sort u_1} →
(t : Plausible.SampleableExt α) →
((proxy : Type v) →
[proxyRepr : Repr proxy] →
[shrink : Plausible.Shrinkable proxy] →
[sample : Plausible.Arbitrary proxy] →
(interp : proxy → α) →
... | null | false |
AddCommGrpCat.hasColimit | Mathlib.Algebra.Category.Grp.Colimits | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] [Small.{w, u} J] (F : CategoryTheory.Functor J AddCommGrpCat),
CategoryTheory.Limits.HasColimit F | null | true |
ENat.exists_eq_iInf | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_1} [Nonempty ι] (f : ι → ℕ∞), ∃ a, f a = ⨅ x, f x | null | true |
_private.Batteries.Data.List.Perm.0.List.getD_set_perm_cons.match_1_1 | Batteries.Data.List.Perm | ∀ {α : Type u_1} (motive : List α → ℕ → α → Prop) (x : List α) (x_1 : ℕ) (x_2 : α),
(∀ (x : ℕ) (x_3 : α), motive [] x x_3) →
(∀ (a : α) (xs : List α) (v : α), motive (a :: xs) 0 v) →
(∀ (a : α) (xs : List α) (i : ℕ) (v : α), motive (a :: xs) i.succ v) → motive x x_1 x_2 | null | false |
Equiv.toHomeomorphOfContinuousClosed._proof_1 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y),
Continuous ⇑e → IsClosedMap ⇑e → Topology.IsInducing ⇑e | null | false |
Std.IterM.attachWith.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α m β] (it : Std.IterM m β)
(P : β → Prop) (h : ∀ (out : β), it.IsPlausibleIndirectOutput out → P out),
it.attachWith P h = { internalState := { inner := it, invariant := h } } | null | true |
Std.DTreeMap.Raw.Const.getD_inter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
m₁.WF →
m₂.WF →
∀ {k : α} {fallback : β},
Std.DTreeMap.Raw.Const.getD (m₁ ∩ m₂) k fallback =
if m₂.contains k = true then Std.DTreeMap.Raw.Const.getD m₁ k fallback else fa... | null | true |
Lean.Meta.Grind.PreInstance.mk | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Array Lean.Expr → Lean.Meta.Grind.PreInstance | null | true |
MvPolynomial.invertibleC._proof_1 | Mathlib.Algebra.MvPolynomial.Invertible | ∀ (σ : Type u_1) {R : Type u_2} [inst : CommSemiring R], MonoidHomClass (R →+* MvPolynomial σ R) R (MvPolynomial σ R) | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.mkPatternFromType.go._unsafe_rec | Lean.Meta.Sym.Pattern | List Lean.Name → Lean.Expr → ℕ → ℕ → Lean.Expr → Array Lean.Expr → Lean.MetaM Lean.Meta.Sym.Pattern | null | false |
RCLike.reCLM | Mathlib.Analysis.RCLike.Basic | {K : Type u_1} → [inst : RCLike K] → StrongDual ℝ K | The real part in an `RCLike` field, as a continuous linear map. | true |
ExteriorAlgebra.liftAlternating._proof_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.OfAlternating | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N], SMulCommClass R R ((i : ℕ) → M [⋀^Fin i]→ₗ[R] N) | null | false |
CategoryTheory.Functor.map_hom_inv | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.IsIso f],
CategoryTheory.CategoryStruct.comp (F.map f) (F.map (CategoryTheory.inv f)) =
CategoryTheory.CategoryStru... | null | true |
List.map₂Right | Mathlib.Data.List.Defs | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → (Option α → β → γ) → List α → List β → List γ | Right-biased version of `List.map₂`. `map₂Right f as bs` applies `f` to each
pair `aᵢ ∈ as` and `bᵢ ∈ bs`. If `as` is shorter than `bs`, `f` is applied to
`none` for the remaining `bᵢ`.
```
map₂Right Prod.mk [1, 2] ['a'] = [(some 1, 'a')]
map₂Right Prod.mk [1] ['a', 'b'] = [(some 1, 'a'), (none, 'b')]
map₂Right f as... | true |
Std.Tactic.BVDecide.BVExpr.bitblast._proof_18 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w : ℕ) (eaig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit)
(evec : eaig.RefVec w),
aig.decls.size ≤ { aig := eaig, vec := evec }.aig.decls.size →
aig.decls.size ≤ (Std.Tactic.BVDecide.BVExpr.bitblast.blastCpop eaig evec).aig.decls.size | null | false |
Pi.faithfulSMul | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {α : ι → Type u_4} [Nonempty ι] [inst : (i : ι) → SMul M (α i)]
[∀ (i : ι), Nonempty (α i)] [∀ (i : ι), FaithfulSMul M (α i)], FaithfulSMul M ((i : ι) → α i) | null | true |
AEMeasurable.sup' | Mathlib.MeasureTheory.Order.Lattice | ∀ {M : Type u_1} [inst : MeasurableSpace M] {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f g : α → M} [inst_1 : Max M] [MeasurableSup₂ M], AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (f ⊔ g) μ | **Alias** of `AEMeasurable.sup`. | true |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.veblenWith.match_1.splitter | Mathlib.SetTheory.Ordinal.Veblen | (o : Ordinal.{u_1}) →
(motive : { x // x ∈ Set.Iio o } → Sort u_2) →
(x : { x // x ∈ Set.Iio o }) → ((x : Ordinal.{u_1}) → (property : x ∈ Set.Iio o) → motive ⟨x, property⟩) → motive x | null | true |
CategoryTheory.Limits.diagramIsoParallelFamily_inv_app | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor (CategoryTheory.Limits.WalkingParallelFamily J) C)
(X : CategoryTheory.Limits.WalkingParallelFamily J),
(CategoryTheory.Limits.diagramIsoParallelFamily F).inv.app X = CategoryTheory.eqToHom ⋯ | null | true |
String.Slice.dropPrefix?_congr | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat]
[inst_1 : String.Slice.Pattern.ForwardPattern pat] [String.Slice.Pattern.Model.LawfulForwardPatternModel pat]
{s t : String.Slice},
s.copy = t.copy → Option.map String.Slice.copy (s.dropPrefix? pat) = Option.map String.Slice.copy (t.dropP... | null | true |
MeasurableEquiv.symm_continuousMapToFun_apply_apply | Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousMap | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : SecondCountableTopology X] [inst_3 : SecondCountableTopology Y] [inst_4 : LocallyCompactSpace X]
[inst_5 : RegularSpace Y] [inst_6 : MeasurableSpace Y] [inst_7 : BorelSpace Y] (f : { g // Continuous g }) (x : X),
(... | null | true |
AlgebraicGeometry.Scheme.Pullback.Triplet.ofPoint_y | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} (t : ↥(CategoryTheory.Limits.pullback f g)),
(AlgebraicGeometry.Scheme.Pullback.Triplet.ofPoint t).y = (CategoryTheory.Limits.pullback.snd f g) t | null | true |
ImportGraph.Lake.BaseLibrary._sizeOf_1 | ImportGraph.WorkspaceModel.Base | ImportGraph.Lake.BaseLibrary → ℕ | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Reduced.0.RootPairing.infinite_of_linearIndependent_coxeterWeight_four._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Reduced | ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a = 0) = (a = 0) | null | false |
Std.Rco._sizeOf_inst | Init.Data.Range.Polymorphic.PRange | (α : Type u) → [SizeOf α] → SizeOf (Std.Rco α) | null | false |
EuclideanGeometry.Sphere.mem_orthRadius_iff_mem_polar_of_mem | Mathlib.Geometry.Euclidean.Sphere.PolePolar | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ≠ s.center → p₂ ∈ s → (p₁ ∈ s.orthRadius p₂ ↔ p₂ ∈ s.polar p₁) | null | true |
FirstOrder.Language.BoundedFormula.restrictFreeVar.match_1 | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u_3} →
{β : Type u_5} →
[inst : DecidableEq α] →
(motive : (x : ℕ) → (x_1 : L.BoundedFormula α x) → (↥x_1.freeVarFinset → β) → Sort u_4) →
(x : ℕ) →
(x_1 : L.BoundedFormula α x) →
(x_2 : ↥x_1.freeVarFinset → β) →
... | null | false |
_private.Batteries.Lean.Position.0.Lean.withDeclRef?.match_1 | Batteries.Lean.Position | (motive : Option Lean.Syntax.Range → Sort u_1) →
(__x : Option Lean.Syntax.Range) →
((range : Lean.Syntax.Range) → motive (some range)) → ((x : Option Lean.Syntax.Range) → motive x) → motive __x | null | false |
CategoryTheory.ObjectProperty.unop_monotone | Mathlib.CategoryTheory.ObjectProperty.Opposite | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {P Q : CategoryTheory.ObjectProperty Cᵒᵖ},
P ≤ Q → P.unop ≤ Q.unop | null | true |
Filter.comap_prodMap_prod | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ) (lb : Filter β) (ld : Filter δ),
Filter.comap (Prod.map f g) (lb ×ˢ ld) = Filter.comap f lb ×ˢ Filter.comap g ld | null | true |
Std.Time.Year.Era.bce.elim | Std.Time.Date.Unit.Year | {motive : Std.Time.Year.Era → Sort u} →
(t : Std.Time.Year.Era) → t.ctorIdx = 0 → motive Std.Time.Year.Era.bce → motive t | null | false |
CategoryTheory.InducedCategory.Hom._sizeOf_1 | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v, u₂} D} →
{F : C → D} → {X Y : CategoryTheory.InducedCategory D F} → [SizeOf C] → [SizeOf D] → X.Hom Y → ℕ | null | false |
SimpleGraph.Walk.IsTrail.isCycle_cycleBypass | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {v : V} [inst : DecidableEq V] {w : G.Walk v v},
w ≠ SimpleGraph.Walk.nil → w.IsTrail → w.cycleBypass.IsCycle | null | true |
FirstOrder.Language.Embedding.substructureEquivMap._proof_2 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_4} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.Embedding M N) (s : L.Substructure M) (n : ↥(FirstOrder.Language.Substructure.map f.toHom s)),
↑n ∈ FirstOrder.Language.Substructure.map f.toHom s | null | false |
Nat.digitChar_eq_three._simp_1 | Init.Data.Nat.ToString | ∀ {n : ℕ}, (n.digitChar = '3') = (n = 3) | null | false |
CategoryTheory.AddMon.forget_map | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : CategoryTheory.AddMon C} (f : X ⟶ Y), (CategoryTheory.AddMon.forget C).map f = f.hom | null | true |
Lean.Elab.Tactic.evalWithUnfoldingAll | Lean.Elab.Tactic.ElabTerm | Lean.Elab.Tactic.Tactic | null | true |
Std.Http.URI.instBEqHost | Std.Http.Data.URI.Basic | BEq Std.Http.URI.Host | null | true |
CategoryTheory.exponentialIdeal_of_preservesBinaryProducts | Mathlib.CategoryTheory.Monoidal.Closed.Ideal | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
(i : CategoryTheory.Functor D C) [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
[inst_3 : CategoryTheory.Reflective i] [inst_4 : CategoryTheory.MonoidalClosed C]
[CategoryTheory.Cartesian... | If the reflector preserves binary products, the subcategory is an exponential ideal.
This is the converse of `preservesBinaryProductsOfExponentialIdeal`.
| true |
DerivedCategory.instLinear | Mathlib.Algebra.Homology.DerivedCategory.Linear | (R : Type t) →
[inst : Ring R] →
(C : Type u) →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Abelian C] →
[CategoryTheory.Linear R C] → [inst_4 : HasDerivedCategory C] → CategoryTheory.Linear R (DerivedCategory C) | null | true |
meromorphicOrderAt_pow | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_4} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {f : 𝕜 → 𝕜'} {x : 𝕜},
MeromorphicAt f x → ∀ {n : ℕ}, meromorphicOrderAt (f ^ n) x = ↑n * meromorphicOrderAt f x | The order multiplies by `n` when taking a meromorphic function to its `n`th power. | true |
MaxTropical.instConditionallyCompleteLattice.eq_1 | Mathlib.Algebra.Tropical.Lattice | ∀ {R : Type u_1} [inst : ConditionallyCompleteLattice R],
MaxTropical.instConditionallyCompleteLattice =
{ toLattice := MaxTropical.instLattice, toSupSet := MaxTropical.instSupSet, toInfSet := MaxTropical.instInfSet,
isLUB_csSup := ⋯, isGLB_csInf := ⋯ } | null | true |
CategoryTheory.GrothendieckTopology.Cover.Arrow._sizeOf_inst | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{X : C} → {J : CategoryTheory.GrothendieckTopology C} → (S : J.Cover X) → [SizeOf C] → SizeOf S.Arrow | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.OfKernel.kerFun._simp_1 | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {α : Type u_1} [inst : MulZeroClass α] {a b : α} [inst_1 : Preorder α] [PosMulMono α],
0 ≤ a → 0 ≤ b → (0 ≤ a * b) = True | null | false |
_private.Lean.Util.FindMVar.0.Lean.FindMVar.main.match_1 | Lean.Util.FindMVar | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((typeName : Lean.Name) → (idx : ℕ) → (e : Lean.Expr) → motive (Lean.Expr.proj typeName idx e)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((b... | null | false |
String.Pos.Raw.IsValid.isValidUTF8_extract_zero | Init.Data.String.Defs | ∀ {s : String} {off : String.Pos.Raw}, String.Pos.Raw.IsValid s off → (s.toByteArray.extract 0 off.byteIdx).IsValidUTF8 | null | true |
pow_two_semiclosed | Mathlib.Algebra.Order.Group.Lattice | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] [MulLeftMono α] [MulRightMono α] {a : α}, 1 ≤ a ^ 2 → 1 ≤ a | null | true |
CategoryTheory.Functor.Full.mk._flat_ctor | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D}, (∀ {X Y : C}, Function.Surjective F.map) → F.Full | null | false |
isClosed_setOfPred_map_neg | Mathlib.Topology.Algebra.Group.ContinuousInv | ∀ (G₁ : Type u_5) (G₂ : Type u_6) [inst : TopologicalSpace G₂] [T2Space G₂] [inst_2 : Neg G₁] [inst_3 : Neg G₂]
[ContinuousNeg G₂], IsClosed {f | ∀ (x : G₁), f (-x) = -f x} | null | true |
AlgebraicGeometry.instUniqueI₀SchemeCover._proof_3 | Mathlib.AlgebraicGeometry.Morphisms.UnderlyingMap | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (hf : P f)
[inst : AlgebraicGeometry.Surjective f] (a : (AlgebraicGeometry.Scheme.Hom.cover f hf).I₀), a = default | null | false |
AlgebraicGeometry.specZIsTerminal._proof_1 | Mathlib.AlgebraicGeometry.Limits | CategoryTheory.Limits.PreservesLimit (CategoryTheory.Functor.empty CommRingCatᵒᵖ) AlgebraicGeometry.Scheme.Spec | null | false |
CategoryTheory.MonoidalCategory.associator_naturality_middle_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C) {Y Y' : C}
(f : Y ⟶ Y') (Z : C) {Z_1 : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y' Z) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp
(Ca... | null | true |
Bool.not_eq_false | Init.SimpLemmas | ∀ (b : Bool), (¬b = false) = (b = true) | null | true |
FirstOrder.Ring.oneFunc | Mathlib.ModelTheory.Algebra.Ring.Basic | FirstOrder.Language.ring.Functions 0 | `RingFunc.one`, but with the defeq type `Language.ring.Functions 0` instead
of `RingFunc 0` | true |
_private.Std.Http.Protocol.H1.Parser.0.Std.Http.Protocol.H1.hex | Std.Http.Protocol.H1.Parser | Std.Internal.Parsec.ByteArray.Parser ℕ | Parses a hexadecimal integer (one or more hex digits, up to 16 digits).
Used for chunk-size lines in chunked transfer encoding.
| true |
Matrix.kroneckerTMulStarAlgEquiv._proof_1 | Mathlib.RingTheory.MatrixAlgebra | ∀ (m : Type u_1) (n : Type u_3) (R : Type u_5) (S : Type u_6) (A : Type u_2) (B : Type u_4) [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Fintype n]
[inst_6 : DecidableEq n] [inst_7 : CommSemiring S] [inst_8 : Algebra R S] [inst_9 : Algeb... | null | false |
NonUnitalStarSubalgebra.isClosed_topologicalClosure | Mathlib.Topology.Algebra.NonUnitalStarAlgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : TopologicalSpace A] [inst_2 : Star A]
[inst_3 : NonUnitalSemiring A] [inst_4 : Module R A] [inst_5 : ContinuousStar A] [inst_6 : ContinuousConstSMul R A]
[inst_7 : IsSemitopologicalSemiring A] (s : NonUnitalStarSubalgebra R A), IsClosed ↑s.topologica... | null | true |
PolynomialLaw.smul._proof_2 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_1} [inst : CommSemiring 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] (r : R) (f : M →ₚₗ[R] N) {S : Type u_1} [inst_5 : CommSemiring S]
[inst_6 : Algebra R S] {S' : Type u_1} [inst_7 : CommSemiring S'] [inst_8 : Algeb... | null | false |
SFinKer.instCopyDiscardCategory._proof_3 | Mathlib.Probability.Kernel.Category.SFinKer | ∀ (X Y : SFinKer),
CategoryTheory.ComonObj.counit =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom CategoryTheory.ComonObj.counit CategoryTheory.ComonObj.counit)
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit SFi... | null | false |
CategoryTheory.Functor.leftDerivedZeroIsoSelf_hom_inv_id_assoc | Mathlib.CategoryTheory.Abelian.LeftDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasProjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive]
[inst_6 : Cate... | null | true |
List.isNone_findFinIdx? | Init.Data.List.Find | ∀ {α : Type u_1} {l : List α} {p : α → Bool}, (List.findFinIdx? p l).isNone = l.all fun x => decide ¬p x = true | null | true |
Lean.LocalContext.noConfusion | Lean.LocalContext | {P : Sort u} → {t t' : Lean.LocalContext} → t = t' → Lean.LocalContext.noConfusionType P t t' | null | false |
HomogeneousSubmodule.mk.inj | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule | ∀ {ιA : Type u_1} {ιM : Type u_2} {σA : Type u_3} {σM : Type u_4} {A : Type u_5} {M : Type u_6} {inst : Semiring A}
{inst_1 : AddCommMonoid M} {inst_2 : Module A M} {𝒜 : ιA → σA} {ℳ : ιM → σM} {inst_3 : DecidableEq ιA}
{inst_4 : AddMonoid ιA} {inst_5 : SetLike σA A} {inst_6 : AddSubmonoidClass σA A} {inst_7 : Grad... | null | true |
PiTensorProduct.map₂ | Mathlib.LinearAlgebra.PiTensorProduct.Basic | {ι : Type u_1} →
{R : Type u_4} →
[inst : CommSemiring R] →
{s : ι → Type u_7} →
[inst_1 : (i : ι) → AddCommMonoid (s i)] →
[inst_2 : (i : ι) → Module R (s i)] →
{t : ι → Type u_11} →
{t' : ι → Type u_12} →
[inst_3 : (i : ι) → AddCommMonoid (t i)] ... | Let `sᵢ`, `tᵢ` and `t'ᵢ` be families of `R`-modules, then `f : Πᵢ sᵢ → tᵢ → t'ᵢ` induces an
element of `Hom(⨂ᵢ sᵢ, Hom(⨂ tᵢ, ⨂ᵢ t'ᵢ))` defined by `⨂ᵢ aᵢ ↦ ⨂ᵢ bᵢ ↦ ⨂ᵢ fᵢ aᵢ bᵢ`.
This is `PiTensorProduct.map` for two arbitrary families of modules.
This is `TensorProduct.map₂` for families of modules.
| true |
CategoryTheory.AB4StarOfSize.rec | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasProducts C] →
{motive : CategoryTheory.AB4StarOfSize.{w, v, u} C → Sort u_1} →
((ofShape : ∀ (α : Type w), CategoryTheory.HasExactLimitsOfShape (CategoryTheory.Discrete α) C) → motive ⋯) →
(t : Ca... | null | false |
Classical.Order.instLT | Init.Data.Order.Lemmas | {α : Type u} → [LE α] → LT α | null | true |
Lean.MessageDataContext.mk.sizeOf_spec | Lean.Message | ∀ (env : Lean.Environment) (mctx : Lean.MetavarContext) (lctx : Lean.LocalContext) (opts : Lean.Options),
sizeOf { env := env, mctx := mctx, lctx := lctx, opts := opts } =
1 + sizeOf env + sizeOf mctx + sizeOf lctx + sizeOf opts | null | true |
Function.Embedding.coe_quotientOut | Mathlib.Logic.Embedding.Basic | ∀ (α : Sort u_1) [inst : Setoid α], ⇑(Function.Embedding.quotientOut α) = Quotient.out | null | true |
_private.Mathlib.Algebra.Order.Ring.Archimedean.0.ArchimedeanClass.instLinearOrderedAddCommMonoidWithTop._simp_2 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] {x : R},
x ≠ 0 → IsAddRegular (ArchimedeanClass.mk x) = True | null | false |
CategoryTheory.MorphismProperty.HasLocalization.D | Mathlib.CategoryTheory.Localization.HasLocalization | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
(W : CategoryTheory.MorphismProperty C) → [self : W.HasLocalization] → Type u | the objects of the localized category. | true |
CategoryTheory.Presheaf.freeYonedaHomEquiv_comp | Mathlib.CategoryTheory.Generator.Presheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A]
[inst_2 : CategoryTheory.Limits.HasCoproducts A] {X : C} {M : A} {F G : CategoryTheory.Functor Cᵒᵖ A}
(α : CategoryTheory.Presheaf.freeYoneda X M ⟶ F) (f : F ⟶ G),
CategoryTheory.Presheaf.freeYoned... | null | true |
_private.Mathlib.Analysis.Normed.Module.RCLike.Basic.0.LinearMap.bound_of_sphere_bound._simp_1_3 | Mathlib.Analysis.Normed.Module.RCLike.Basic | (¬False) = True | null | false |
geom_sum_of_one_lt | Mathlib.Algebra.Order.Field.GeomSum | ∀ {K : Type u_1} [inst : Semifield K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] [CanonicallyOrderedAdd K]
[inst_4 : Sub K] [OrderedSub K] {x : K}, 1 < x → ∀ (n : ℕ), ∑ i ∈ Finset.range n, x ^ i = (x ^ n - 1) / (x - 1) | null | true |
_private.Mathlib.SetTheory.Cardinal.Subfield.0.Subfield.Operands | Mathlib.SetTheory.Cardinal.Subfield | {α : Type u} → (s : Set α) → Fin 6 ⊕ ↑s → Type | null | true |
WithBot.instLocallyFiniteOrder._proof_8 | Mathlib.Order.Interval.Finset.Defs | ∀ (α : Type u_1) [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : LocallyFiniteOrder α] (a b x : WithBot α),
(x ∈
match a, b with
| none, x => ∅
| some a, none => Finset.map Function.Embedding.coeWithBot (Finset.Iio a)
| some a, some b => Finset.map Function.Embedding.coeWithBot (Finset... | null | false |
Int.add_right_inj._simp_1 | Init.Data.Int.Lemmas | ∀ {i j : ℤ} (k : ℤ), (k + i = k + j) = (i = j) | null | false |
AddCommMonCat.coe_comp | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : AddCommMonCat} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) | null | true |
String.Slice.skipSuffixWhile_eq_endPos_iff._simp_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat]
[String.Slice.Pattern.Model.StrictPatternModel pat] [inst_2 : String.Slice.Pattern.BackwardPattern pat]
[String.Slice.Pattern.Model.LawfulBackwardPatternModel pat] {s : String.Slice},
(s.skipSuffixWhile pat = s.endPos) = (s.endsWith pat =... | null | false |
Disjoint.eq_bot | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b → a ⊓ b = ⊥ | null | true |
Std.DTreeMap.Internal.Impl.Const.some_minEntry_eq_minEntry? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [Ord α] {l : Std.DTreeMap.Internal.Impl α fun x => β} {he : l.isEmpty = false},
some (Std.DTreeMap.Internal.Impl.Const.minEntry l he) = Std.DTreeMap.Internal.Impl.Const.minEntry? l | null | true |
CuspForm.instAddCommGroup._proof_7 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ}, autoParam (∀ (a : CuspForm Γ k), 0 • a = 0) SubNegMonoid.zsmul_zero'._autoParam | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.