name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Num.instOrOp | Mathlib.Data.Num.Bitwise | OrOp Num | null | true |
AlgebraicGeometry.StructureSheaf.const_apply | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R M : Type u} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : M) (g : R)
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (hu : ∀ x ∈ U, g ∈ x.asIdeal.primeCompl)
(x : ↥U), ↑(AlgebraicGeometry.StructureSheaf.const f g U hu) x = LocalizedModule.mk f ⟨g, ⋯⟩ | null | true |
instCommCStarAlgebraSubtypeMemStarSubalgebraComplexElementalOfIsStarNormal._proof_9 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : CStarAlgebra A] (x : A), StarModule ℂ ↥(StarAlgebra.elemental ℂ x) | null | false |
Submodule.mem_toAffineSubspace._simp_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V] {p : Submodule k V}
{x : V}, (x ∈ ↑p) = (x ∈ p) | null | false |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.AddContent.onIoc._proof_14 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} [inst : LinearOrder α] (I : Finset (Set α)) (u v u' : α),
u ≤ u' →
⋃₀ ↑(I.erase (Set.Ioc u' v)) = Set.Ioc u u' → ⋃₀ ↑(I.erase (Set.Ioc u' v)) ∈ {s | ∃ u v, u ≤ v ∧ s = Set.Ioc u v} | null | false |
Lean.Meta.SolveByElim.SolveByElimConfig.testSolutions | Lean.Meta.Tactic.SolveByElim | optParam Lean.Meta.SolveByElim.SolveByElimConfig { } →
(List Lean.Expr → Lean.MetaM Bool) → Lean.Meta.SolveByElim.SolveByElimConfig | Create or modify a `SolveByElimConfig` which rejects complete solutions for which `test`,
applied to the instantiations of the original goals, fails or returns `false`.
| true |
Tactic.ComputeAsymptotics.UnitMonomial.isLittleO_of_lt | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | ∀ {basis : Tactic.ComputeAsymptotics.Basis} {m1 m2 : Tactic.ComputeAsymptotics.UnitMonomial},
Tactic.ComputeAsymptotics.WellFormedBasis basis →
List.length m1 = List.length basis →
List.length m2 = List.length basis → m1 < m2 → m1.toFun basis =o[Filter.atTop] m2.toFun basis | null | true |
CategoryTheory.MorphismProperty.pushout_inl | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C} {A B A' : C}
(f : A ⟶ A') (g : A ⟶ B) [inst_1 : CategoryTheory.Limits.HasPushout f g] [P.IsStableUnderCobaseChangeAlong f],
P g → P (CategoryTheory.Limits.pushout.inl f g) | null | true |
ContinuousSemilinearEquivClass.map_continuous | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} {inst : Semiring R} {inst_1 : Semiring S}
{σ : outParam (R →+* S)} {σ' : outParam (S →+* R)} {inst_2 : RingHomInvPair σ σ'} {inst_3 : RingHomInvPair σ' σ}
{M : outParam (Type u_4)} {inst_4 : TopologicalSpace M} {inst_5 : AddCommMonoid M} {M₂ : out... | `ContinuousSemilinearEquivClass F σ M M₂` asserts `F` is a type of bundled continuous
`σ`-semilinear equivs `M → M₂`. See also `ContinuousLinearEquivClass F R M M₂` for the case
where `σ` is the identity map on `R`. A map `f` between an `R`-module and an `S`-module over a ring
homomorphism `σ : R →+* S` is semilinear... | true |
CategoryTheory.ShortComplex.FunctorEquivalence.inverse_map_τ₂ | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} (φ : X ⟶ Y),
((CategoryTheory.ShortComplex.FunctorEquivalence.inverse J... | null | true |
Polynomial.cyclotomic_irreducible_pow_of_irreducible_pow | Mathlib.RingTheory.Polynomial.Cyclotomic.Expand | ∀ {p : ℕ},
Nat.Prime p →
∀ {R : Type u_1} [inst : CommRing R] [IsDomain R] {n m : ℕ},
m ≤ n → Irreducible (Polynomial.cyclotomic (p ^ n) R) → Irreducible (Polynomial.cyclotomic (p ^ m) R) | If the `p ^ n`th cyclotomic polynomial is irreducible, so is the `p ^ m`th, for `m ≤ n`. | true |
iInter_smul_subset | Mathlib.Analysis.LocallyConvex.BalancedCoreHull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NormedDivisionRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
(s : Set E), ⋂ r, ⋂ (_ : 1 ≤ ‖r‖), r • s ⊆ s | null | true |
_private.Mathlib.Data.Seq.Computation.0.Stream'.cons.match_1.eq_2 | Mathlib.Data.Seq.Computation | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n | null | true |
Lean.Name.componentsRev._sunfold | Lean.Data.Name | Lean.Name → List Lean.Name | null | false |
PartialEquiv.image_symm_image_of_subset_target | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) {s : Set β}, s ⊆ e.target → ↑e '' ↑e.symm '' s = s | null | true |
DistLat.Iso.mk._proof_2 | Mathlib.Order.Category.DistLat | ∀ {α β : DistLat} (e : ↑α ≃o ↑β),
CategoryTheory.CategoryStruct.comp (DistLat.ofHom { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ })
(DistLat.ofHom { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ }) =
CategoryTheory.CategoryStruct.id α | null | false |
instCoeTCAddEquivOfAddEquivClass | Mathlib.Algebra.Group.Equiv.Defs | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : EquivLike F α β] → [inst_1 : Add α] → [inst_2 : Add β] → [AddEquivClass F α β] → CoeTC F (α ≃+ β) | Any type satisfying `AddEquivClass` can be cast into `AddEquiv` via
`AddEquivClass.toAddEquiv`. | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.maxView.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
(l : Std.DTreeMap.Internal.Impl α β) →
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Sort u_3) →
(r : Std.DTreeMap.Internal.Impl α β) →
(hr : r.Balanced) →
... | null | true |
Aesop.UnorderedArraySet.partition | Aesop.Util.UnorderedArraySet | {α : Type u_1} →
[inst : BEq α] → (α → Bool) → Aesop.UnorderedArraySet α → Aesop.UnorderedArraySet α × Aesop.UnorderedArraySet α | null | true |
CategoryTheory.Limits.Trident.ofι._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {P : C} (ι : P ⟶ X),
(∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp ι (f j₁) = CategoryTheory.CategoryStruct.comp ι (f j₂)) →
∀ (i j : CategoryTheory.Limits.WalkingParallelFamily J... | null | false |
analyticOrderAt_mul_eq_top_of_right | Mathlib.Analysis.Analytic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {f g : 𝕜 → 𝕜} {z₀ : 𝕜},
analyticOrderAt g z₀ = ⊤ → analyticOrderAt (f * g) z₀ = ⊤ | null | true |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.getSepFromSplice._sparseCasesOn_1 | Lean.Elab.Quotation | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive_1 (Lean.Syntax.atom info val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
Lean.Lsp.CompletionParams._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CompletionParams | null | false |
Homeomorph.applyFaithfulSMul | Mathlib.Topology.Algebra.ConstMulAction | ∀ {X : Type u_4} [inst : TopologicalSpace X], FaithfulSMul (X ≃ₜ X) X | `Homeomorph.applyMulAction` is faithful. | true |
_private.Mathlib.MeasureTheory.PiSystem.0.piiUnionInter_singleton._simp_1_6 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | null | false |
Finite.ciInf_inf | Mathlib.Data.Fintype.Order | ∀ {α : Type u_1} {ι : Type u_2} [Finite ι] [inst : ConditionallyCompleteLattice α] [Nonempty ι] {f : ι → α} {a : α},
(⨅ i, f i) ⊓ a = ⨅ i, f i ⊓ a | null | true |
CliffordAlgebra.ofBaseChange_tmul_one | Mathlib.LinearAlgebra.CliffordAlgebra.BaseChange | ∀ {R : Type u_1} (A : Type u_2) {V : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : AddCommGroup V]
[inst_3 : Algebra R A] [inst_4 : Module R V] [inst_5 : Invertible 2] (Q : QuadraticForm R V) (z : A),
(CliffordAlgebra.ofBaseChange A Q) (z ⊗ₜ[R] 1) = (algebraMap A (CliffordAlgebra (QuadraticForm.base... | null | true |
WithVal | Mathlib.Topology.Algebra.Valued.WithVal | {R : Type u_1} →
{Γ₀ : Type u_2} → [inst : LinearOrderedCommGroupWithZero Γ₀] → [inst_1 : Ring R] → Valuation R Γ₀ → Type u_1 | Type synonym for a ring equipped with the topology coming from a valuation. | true |
Int.add_shiftLeft | Init.Data.Int.Bitwise.Lemmas | ∀ (a b : ℤ) (n : ℕ), (a + b) <<< n = a <<< n + b <<< n | null | true |
_private.Mathlib.Order.InitialSeg.0.collapseF | Mathlib.Order.InitialSeg | {α : Type u_1} →
{β : Type u_2} →
{r : α → α → Prop} → {s : β → β → Prop} → [IsWellOrder β s] → (f : r ↪r s) → (a : α) → { b // ¬s (f a) b } | The function in `collapse`. | true |
Finset.sdiv_union | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : SDiv α β] [inst_1 : DecidableEq α] {s t₁ t₂ : Finset β}
[inst_2 : DecidableEq β], s /ₛ (t₁ ∪ t₂) = s /ₛ t₁ ∪ (s /ₛ t₂) | null | true |
_private.Mathlib.MeasureTheory.Constructions.SimpleGraph.0.SimpleGraph.measurable_edgeSet._simp_1_1 | Mathlib.MeasureTheory.Constructions.SimpleGraph | ∀ {V : Type u} (G : SimpleGraph V) {v w : V}, (s(v, w) ∈ G.edgeSet) = G.Adj v w | null | false |
_private.Mathlib.Analysis.Meromorphic.FactorizedRational.0.MeromorphicOn.extract_zeros_poles_log._simp_1_3 | Mathlib.Analysis.Meromorphic.FactorizedRational | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) | null | false |
_private.ImportGraph.Imports.FromSource.0.ImportGraph.parseImports?._sparseCasesOn_1 | ImportGraph.Imports.FromSource | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Tactic.DuplicateDecls.0.Mathlib.Tactic.DuplicateDecls.ModuleKey | Mathlib.Tactic.DuplicateDecls | Type | Structure used for sorting imported modules:
1. The number given by `libraryNumber`.
2. The name of the module as a string.
| true |
Quiver.FreeGroupoid.quotInv | Mathlib.CategoryTheory.Groupoid.FreeGroupoid | {V : Type u} → [inst : Quiver V] → {X Y : Quiver.FreeGroupoid V} → (X ⟶ Y) → (Y ⟶ X) | The inverse of an arrow in the free groupoid | true |
_private.Mathlib.RingTheory.Spectrum.Prime.FreeLocus.0.Module.rankAtStalk_eq_zero_iff_subsingleton._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | null | false |
List.getElem_pmap | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} (f : (a : α) → p a → β) {l : List α} (h : ∀ a ∈ l, p a) {i : ℕ}
(hn : i < (List.pmap f l h).length), (List.pmap f l h)[i] = f l[i] ⋯ | null | true |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Impl.pruneLE.match_1.eq_1 | Std.Data.DTreeMap.Internal.Zipper | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.lt) (h_2 : Unit → motive Ordering.eq)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.lt with
| Ordering.lt => h_1 ()
| Ordering.eq => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () | null | true |
CategoryTheory.Limits.Fork.IsLimit.homIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f g : X ⟶ Y}
{t : CategoryTheory.Limits.Fork f g} (ht : CategoryTheory.Limits.IsLimit t) (Z : C) (x : Z ⟶ t.pt),
↑(CategoryTheory.Limits.Fork.IsLimit.lift' ht ↑⟨CategoryTheory.CategoryStruct.comp x t.ι, ⋯⟩ ⋯) = x | null | false |
CategoryTheory.Limits.cospanCompIso_inv_app_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {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 Z : C} (f : X ⟶ Z) (g : Y ⟶ Z),
(CategoryTheory.Limits.cospanCompIso F f g).inv.app CategoryTheory.Limits.WalkingCospan.left =
CategoryTheory.CategoryStruct.... | null | true |
EuclideanGeometry.Sphere.ext_iff | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {P : Type u_2} {inst : MetricSpace P} {x y : EuclideanGeometry.Sphere P},
x = y ↔ x.center = y.center ∧ x.radius = y.radius | null | true |
Fin.image_castSucc_Ioi | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i : Fin n), Fin.castSucc '' Set.Ioi i = Set.Ioo i.castSucc (Fin.last n) | null | true |
Mathlib.Meta.Positivity.div_nonneg_of_pos_of_nonneg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_3} [inst : GroupWithZero α] [inst_1 : PartialOrder α] {a b : α} [PosMulReflectLT α],
0 < a → 0 ≤ b → 0 ≤ a / b | null | true |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.eVariationOn.eVariationOn_on_inter_Iic_eq_Iio_add_edist._proof_1_10 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_2} {M : Type u_1} [inst : PseudoEMetricSpace M] {f : α → M} {a : α} (n : ℕ) (u : ℕ → α) (y : α),
∀ i ∈ Finset.range n,
edist (f (u (i + 1))) (f (u i)) ≤
edist (f ((fun i => if i ≤ n then u i else if i = n + 1 then y else a) (i + 1)))
(f ((fun i => if i ≤ n then u i else if i = n + 1 th... | null | false |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀._auto_1 | Mathlib.CategoryTheory.ComposableArrows.Four | Lean.Syntax | null | false |
Filter.EventuallySubset.rfl | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s : Set α} {l : Filter α}, s ≤ᶠ[l] s | null | true |
IsStrongFEPair.casesOn | Mathlib.NumberTheory.LSeries.AbstractFuncEq | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℂ E] →
{P : WeakFEPair E} →
{motive : IsStrongFEPair P → Sort u} →
(t : IsStrongFEPair P) → ((hf₀ : P.f₀ = 0) → (hg₀ : P.g₀ = 0) → motive ⋯) → motive t | null | false |
Lean.PrettyPrinter.OneLine.State.mk._flat_ctor | Lean.PrettyPrinter.Formatter | Std.Format → ℕ → List (ℕ × Std.Format) → Lean.PrettyPrinter.OneLine.State | null | false |
_private.Mathlib.Algebra.Polynomial.Splits.0.Polynomial.Splits.comp_of_natDegree_le_one_of_invertible._simp_1_1 | Mathlib.Algebra.Polynomial.Splits | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b | null | false |
lt_sSup_iff | Mathlib.Order.CompleteLattice.Defs | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] {s : Set α} {b : α}, b < sSup s ↔ ∃ a ∈ s, b < a | null | true |
_private.Init.Data.List.SplitOn.Basic.0.List.splitOnPTR.go.eq_def | Init.Data.List.SplitOn.Basic | ∀ {α : Type u_1} (p : α → Bool) (a : List α) (a_1 : Array α) (a_2 : Array (List α)),
List.splitOnPTR.go✝ p a a_1 a_2 =
match a, a_1, a_2 with
| [], acc, r => r.toListAppend [acc.toList]
| a :: t, acc, r =>
if p a = true then List.splitOnPTR.go✝ p t #[] (r.push acc.toList) else List.splitOnPTR.go✝ p ... | null | true |
Lean.Compiler.LCNF.Simp.CtorInfo.ctor.inj | Lean.Compiler.LCNF.Simp.DiscrM | ∀ {val : Lean.ConstructorVal} {args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)}
{val_1 : Lean.ConstructorVal} {args_1 : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)},
Lean.Compiler.LCNF.Simp.CtorInfo.ctor val args = Lean.Compiler.LCNF.Simp.CtorInfo.ctor val_1 args_1 →
val =... | null | true |
Std.ExtDTreeMap.getKey_insert_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k}, (t.insert k v).getKey k ⋯ = k | null | true |
CategoryTheory.Functor.LaxMonoidal.tensorHom_ε_comp_μ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] {X : C} {Y : D} (f : Y ⟶ F.obj X) {Z : D}
(h :... | null | true |
CategoryTheory.Lax.OplaxTrans.vCompNaturality | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G H : CategoryTheory.LaxFunctor B C} →
(η : CategoryTheory.Lax.OplaxTrans F G) →
(θ : CategoryTheory.Lax.OplaxTrans G H) →
{a b : B} →
... | Auxiliary definition for `vComp`. | true |
Ordering.isEq | Init.Data.Ord.Basic | Ordering → Bool | Checks whether the ordering is `eq`.
| true |
List.Vector.set._proof_1 | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (v : List.Vector α n) (i : Fin n) (a : α), ((↑v).set (↑i) a).length = n | null | false |
Std.Tactic.BVDecide.LRAT.Internal.State.mem_toCNF_of_eq_some | Std.Tactic.BVDecide.LRAT.Internal.Basic | ∀ {idx : ℕ} {c : Std.Sat.CNF.Clause ℕ} {s : Std.Tactic.BVDecide.LRAT.Internal.State}, s.get? idx = some c → c ∈ s.toCNF | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.map_mono._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
List.ofFn_congr | Mathlib.Data.List.OfFn | ∀ {α : Type u} {m n : ℕ} (h : m = n) (f : Fin m → α), List.ofFn f = List.ofFn fun i => f (Fin.cast ⋯ i) | null | true |
Std.DTreeMap.Raw.self_le_maxKey?_insert | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
(h : t.WF) {k : α} {v : β k} {kmi : α}, (t.insert k v).maxKey?.get ⋯ = kmi → (cmp k kmi).isLE = true | null | true |
_private.Mathlib.SetTheory.Ordinal.Exponential.0.Ordinal.lt_omega0_omega0_opow._simp_1_6 | Mathlib.SetTheory.Ordinal.Exponential | ∀ {a : Ordinal.{u_1}} (b : Ordinal.{u_1}), 0 < a → (0 < a ^ b) = True | null | false |
_private.Mathlib.Probability.Martingale.Upcrossing.0.MeasureTheory.upcrossingStrat_le_one._simp_1_2 | Mathlib.Probability.Martingale.Upcrossing | ∀ {α : Type v} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
Disjoint (Set.Ico a₁ a₂) (Set.Ico b₁ b₂) = (min a₂ b₂ ≤ max a₁ b₁) | null | false |
AlgHom.toEnd._proof_1 | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
AlgHom.toLinearMap 1 = AlgHom.toLinearMap 1 | null | false |
Lean.NameHashSet.insert | Lean.Data.NameMap.Basic | Lean.NameHashSet → Lean.Name → Std.HashSet Lean.Name | null | true |
CategoryTheory.PreOneHypercover.congrIndexOneOfEqIso_inv_p₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{i i' j j' : E.I₀} (hii' : i = i') (hjj' : j = j') (k : E.I₁ i j),
CategoryTheory.CategoryStruct.comp (CategoryTheory.PreOneHypercover.congrIndexOneOfEqIso hii' hjj' k).inv
(E.p₁ ((CategoryTheory.PreOneHyp... | null | true |
BooleanSubalgebra | Mathlib.Order.BooleanSubalgebra | (α : Type u_2) → [BooleanAlgebra α] → Type u_2 | A Boolean subalgebra of a Boolean algebra is a set containing the bottom and top elements, and
closed under suprema, infima and complements. | true |
LocallyConstant.instNonUnitalCommSemiring | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} →
{Y : Type u_2} → [inst : TopologicalSpace X] → [NonUnitalCommSemiring Y] → NonUnitalCommSemiring (LocallyConstant X Y) | null | true |
MulAction.index_centralizer_eq_ncard | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] (g : G), (Subgroup.centralizer {g}).index = (conjugatesOf g).ncard | **Alias** of `Subgroup.index_centralizer_eq_ncard`. | true |
_private.Mathlib.Tactic.Linter.Whitespace.0.Mathlib.Linter.FormatError.mk._flat_ctor | Mathlib.Tactic.Linter.Whitespace | ℕ → String.Pos.Raw → ℕ → String → ℕ → String.Pos.Raw → Mathlib.Linter.FormatError✝ | null | false |
ContinuousAffineMap.decompContinuousLinearEquiv._proof_4 | Mathlib.Topology.Algebra.ContinuousAffineMap.Topology | ∀ (R : Type u_1) (V : Type u_2) (W : Type u_3) [inst : NormedField R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : TopologicalSpace V] [inst_4 : AddCommGroup W] [inst_5 : Module R W] [inst_6 : TopologicalSpace W]
[inst_7 : IsTopologicalAddGroup V] [inst_8 : IsTopologicalAddGroup W] [inst_9 : Continuous... | null | false |
Lean.Elab.Tactic.checkTerminalAsSorry | Lean.Elab.Tactic.Grind.Main | Lean.MVarId → Lean.Elab.Tactic.TacticM Bool | null | true |
Lean.Meta.Monotonicity.defaultFailK | Lean.Elab.Tactic.Monotonicity | {α : Type} → Lean.Expr → Array Lean.Name → Lean.MetaM α | null | true |
MeasurableSpace.sUnion_countablePartition | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ (α : Type u_3) [inst : MeasurableSpace α] [inst_1 : MeasurableSpace.CountablyGenerated α] (n : ℕ),
⋃₀ MeasurableSpace.countablePartition α n = Set.univ | null | true |
Delone.DeloneSet.mapIsometry_symm_apply_packingRadius | Mathlib.Analysis.AperiodicOrder.Delone.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : MetricSpace X] [inst_1 : MetricSpace Y] (f : X ≃ᵢ Y) (D : Delone.DeloneSet Y),
((Delone.DeloneSet.mapIsometry f).symm D).packingRadius = D.packingRadius | null | true |
ChartedSpaceCore.noConfusionType | Mathlib.Geometry.Manifold.ChartedSpace | Sort u →
{H : Type u_4} →
[inst : TopologicalSpace H] →
{M : Type u_5} →
ChartedSpaceCore H M →
{H' : Type u_4} → [inst' : TopologicalSpace H'] → {M' : Type u_5} → ChartedSpaceCore H' M' → Sort u | null | false |
Submodule.lTensorOne'.eq_1 | Mathlib.LinearAlgebra.TensorProduct.Submodule | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (N : Submodule R S),
N.lTensorOne' =
↑(LinearEquiv.ofEq ((Subalgebra.toSubmodule ⊥).mulMap N).range N ⋯) ∘ₗ
((Subalgebra.toSubmodule ⊥).mulMap N).rangeRestrict | null | true |
_private.Lean.Expr.0.Lean.Expr.getAppArgsAux._f | Lean.Expr | (x : Lean.Expr) →
Lean.Expr.below (motive := fun x => Array Lean.Expr → ℕ → Array Lean.Expr) x → Array Lean.Expr → ℕ → Array Lean.Expr | null | false |
CategoryTheory.Functor.FullyFaithful.autMulEquivOfFullyFaithful_apply_asIso_inv | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{f : CategoryTheory.Functor C D} (hf : f.FullyFaithful) (X : C) (a : CategoryTheory.Aut X),
((hf.autMulEquivOfFullyFaithful X) a).asIso.inv = f.map a.asIso.inv | null | true |
_private.Mathlib.NumberTheory.JacobiSum.Basic.0.jacobiSum_nontrivial_inv._simp_1_11 | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
HomotopicalAlgebra.CofibrantObject.HoCat.bifibrantResolution'._proof_1 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(X : HomotopicalAlgebra.CofibrantObject C),
CategoryTheory.CategoryStruct.comp (HomotopicalAlgebra.CofibrantObject.toHoCat.map X.iBifibrantResolutionObj)
(HomotopicalAlgebra.BifibrantObject.HoCat.ιCofi... | null | false |
Lean.StructureFieldInfo.noConfusionType | Lean.Structure | Sort u → Lean.StructureFieldInfo → Lean.StructureFieldInfo → Sort u | null | false |
Std.Http.Method._sizeOf_1 | Std.Http.Data.Method | Std.Http.Method → ℕ | null | false |
UInt64.mul_assoc | Init.Data.UInt.Lemmas | ∀ (a b c : UInt64), a * b * c = a * (b * c) | null | true |
Batteries.Tactic.TransRelation._sizeOf_1 | Batteries.Tactic.Trans | Batteries.Tactic.TransRelation → ℕ | null | false |
EuclideanGeometry.Sphere.secondInter_mem._simp_1 | Mathlib.Geometry.Euclidean.Sphere.SecondInter | ∀ {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} (v : V), (s.secondInter p v ∈ s) = (p ∈ s) | null | false |
Std.DHashMap.Raw.Const.get!_filter_of_getKey?_eq_some | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited β] {f : α → β → Bool} {k k' : α},
m.WF →
m.getKey? k = some k' →
Std.DHashMap.Raw.Const.get! (Std.DHashMap.Raw.filter f m) k =
(Option.filter (fu... | null | true |
_private.Lean.Meta.InferType.0.Lean.Meta.isArrowProposition'.match_1 | Lean.Meta.InferType | (motive : Lean.Expr → ℕ → Sort u_1) →
(x : Lean.Expr) →
(x_1 : ℕ) →
((binderName : Lean.Name) →
(t b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → (n : ℕ) → motive (Lean.Expr.forallE binderName t b binderInfo) n.succ) →
((declName : Lean.Name) →
(t value b : Lean.... | null | false |
PowerBasis.mk.injEq | Mathlib.RingTheory.PowerBasis | ∀ {R : Type u_6} {S : Type u_7} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (gen : S) (dim : ℕ)
(basis : Module.Basis (Fin dim) R S) (basis_eq_pow : ∀ (i : Fin dim), basis i = gen ^ ↑i) (gen_1 : S) (dim_1 : ℕ)
(basis_1 : Module.Basis (Fin dim_1) R S) (basis_eq_pow_1 : ∀ (i : Fin dim_1), basis_1 i =... | null | true |
PadicAlgCl.isUltrametricDist | Mathlib.NumberTheory.Padics.Complex | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], IsUltrametricDist (PadicAlgCl p) | The underlying metric space of `PadicAlgCl p` is ultrametric. | true |
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.realize_toPrenexImp._simp_1_2 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {φ ψ : L.BoundedFormula α l}
{v : α → M} {xs : Fin l → M}, (φ.imp ψ).Realize v xs = (φ.Realize v xs → ψ.Realize v xs) | null | false |
sdiff_sdiff_le | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, b \ (b \ a) ≤ a | null | true |
Lean.PrettyPrinter.Formatter.categoryFormatter | Lean.PrettyPrinter.Formatter | Lean.Name → Lean.PrettyPrinter.Formatter | null | true |
CategoryTheory.ComposableArrows.Exact.cokerIsoKer_hom_fac | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Balanced C] {n : ℕ} {S : CategoryTheory.ComposableArrows C (n + 3)} (hS : S.Exact) (k : ℕ)
(hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.cokerIsoKer_hom_fac._auto_1)
[ins... | null | true |
_private.Init.Data.Array.Basic.0.Array.takeWhile.go._unary._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α) (i : ℕ) (acc : Array α) (h : i < as.size),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i acc => as.size - i) ⟨i + 1, acc.push as[i]⟩ ⟨i, acc⟩ | null | false |
Std.Time.Modifier.F | Std.Time.Format.Modifier | Std.Time.Number → Std.Time.Modifier | `F`: Day-of-week-in-month / occurrence of the weekday within the month (e.g., 2nd Sunday -> 2).
| true |
StateRefT'.run | Init.Control.StateRef | {ω σ : Type} → {m : Type → Type} → [Monad m] → [MonadLiftT (ST ω) m] → {α : Type} → StateRefT' ω σ m α → σ → m (α × σ) | Executes an action from a monad with added state in the underlying monad `m`. Given an initial
state, it returns a value paired with the final state.
The monad `m` must support `ST` effects in order to create and mutate reference cells.
| true |
IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers | Mathlib.RingTheory.DedekindDomain.AdicValuation | {R : Type u_1} →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
(K : Type u_2) →
[inst_2 : Field K] →
[inst_3 : Algebra R K] →
[inst_4 : IsFractionRing R K] →
(v : IsDedekindDomain.HeightOneSpectrum R) →
ValuationSubring (IsDedekindDomain.He... | The ring of integers of `adicCompletion`. | true |
Std.Http.Protocol.H1.PulledChunk.mk.sizeOf_spec | Std.Http.Protocol.H1 | ∀ (final incomplete : Bool) (chunk : Std.Http.Chunk),
sizeOf { final := final, incomplete := incomplete, chunk := chunk } =
1 + sizeOf final + sizeOf incomplete + sizeOf chunk | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.