name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SimpleGraph.CompleteEquipartiteSubgraph.ofCopy.match_7 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {V : Type u_1} {G : SimpleGraph V} {r t : ℕ} (f : (SimpleGraph.completeEquipartiteGraph r t).Copy G) {p : Finset V}
(motive : (∃ a, Finset.map { toFun := fun j => f (a, j), inj' := ⋯ } Finset.univ = p) → Prop)
(h : ∃ a, Finset.map { toFun := fun j => f (a, j), inj' := ⋯ } Finset.univ = p),
(∀ (w : Fin r) (h : F... | null | false |
Mathlib.Tactic.FieldSimp.NF.instPowInt | Mathlib.Tactic.FieldSimp.Lemmas | {M : Type u_1} → Pow (Mathlib.Tactic.FieldSimp.NF M) ℤ | null | true |
CategoryTheory.Limits.WalkingReflexivePair.Hom.leftCompReflexion.elim | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | {motive : (a a_1 : CategoryTheory.Limits.WalkingReflexivePair) → a.Hom a_1 → Sort u} →
{a a_1 : CategoryTheory.Limits.WalkingReflexivePair} →
(t : a.Hom a_1) →
t.ctorIdx = 3 →
motive CategoryTheory.Limits.WalkingReflexivePair.one CategoryTheory.Limits.WalkingReflexivePair.one
CategoryThe... | null | false |
AddMonoidAlgebra.mapDomain_single | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} {N : Type u_7} [inst : Semiring R] {f : M → N} {a : M} {r : R},
AddMonoidAlgebra.mapDomain f (AddMonoidAlgebra.single a r) = AddMonoidAlgebra.single (f a) r | null | true |
Action.functorCategoryEquivalenceInverseMonoidal._aux_12 | Mathlib.CategoryTheory.Action.Monoidal | (V : Type u_3) →
[inst : CategoryTheory.Category.{u_2, u_3} V] →
(G : Type u_1) →
[inst_1 : Monoid G] →
[inst_2 : CategoryTheory.MonoidalCategory V] →
(X Y : CategoryTheory.Functor (CategoryTheory.SingleObj G) V) →
(Action.functorCategoryEquivalence V G).inverse.obj (CategoryTh... | null | false |
_private.Batteries.Data.Char.AsciiCasing.0.Char.toUpper_toLower_eq_toUpper._proof_1_8 | Batteries.Data.Char.AsciiCasing | ∀ (c : Char), 65 ≤ c.toNat ∧ c.toNat ≤ 90 → ¬(c.toNat + 32).isValidChar → False | null | false |
_private.Mathlib.Algebra.Homology.DerivedCategory.Ext.ExtClass.0.CategoryTheory.ShortComplex.ShortExact.extClass_comp_assoc._proof_1_3 | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExtClass | ∀ {n n' : ℕ} {h : 1 + n = n'}, 1 + 0 + n = n' | null | false |
Ordering.lt.elim | Init.Data.Ord.Basic | {motive : Ordering → Sort u} → (t : Ordering) → t.ctorIdx = 0 → motive Ordering.lt → motive t | null | false |
MulAut.conj._proof_1 | Mathlib.Algebra.Group.End | ∀ {G : Type u_1} [inst : Group G] (g x : G), (fun h => g⁻¹ * h * g) ((fun h => g * h * g⁻¹) x) = x | null | false |
ContinuousCohomology.resolutionMap_comp_d | Mathlib.RepresentationTheory.Homological.ContCohomology.Functoriality | ∀ {k : Type u} {G H : Type v} [inst : Ring k] [inst_1 : TopologicalSpace k] [inst_2 : Group G]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] [inst_5 : Group H] [inst_6 : TopologicalSpace H]
[inst_7 : IsTopologicalGroup H] {X : TopRep k G} {Y : TopRep k H} (φ : H →ₜ* G) (f : TopRep.res (↑φ) X ⟶ Y) (i... | The maps `resolutionMap φ f` commute with the differentials of the resolutions. | true |
FreeGroup.reduce_invRev_left_cancel | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} {L : List (α × Bool)} [inst : DecidableEq α], FreeGroup.reduce (FreeGroup.invRev L ++ L) = [] | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.BoundedVariation.0.BoundedVariationOn.vectorMeasure_Ioi._proof_1_2 | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {E : Type u_1} [inst_7 : NormedAddCommGroup E], Nonempty E | null | false |
AddOreLocalization.addOreCondition.eq_1 | Mathlib.GroupTheory.OreLocalization.OreSet | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] (r : R) (s : ↥S),
AddOreLocalization.addOreCondition r s = ⟨AddOreLocalization.oreMin r s, ⟨AddOreLocalization.oreSubtra r s, ⋯⟩⟩ | null | true |
Nat.Partrec.rfind | Mathlib.Computability.Partrec | ∀ {f : ℕ →. ℕ}, Nat.Partrec f → Nat.Partrec fun a => Nat.rfind fun n => (fun m => decide (m = 0)) <$> f (Nat.pair a n) | null | true |
ProofWidgets.Penrose.DiagramProps.recOn | ProofWidgets.Component.PenroseDiagram | {motive : ProofWidgets.Penrose.DiagramProps → Sort u} →
(t : ProofWidgets.Penrose.DiagramProps) →
((embeds : Array (String × ProofWidgets.Html)) →
(dsl sty sub : String) →
(maxOptSteps : ℕ) →
motive { embeds := embeds, dsl := dsl, sty := sty, sub := sub, maxOptSteps := maxOptSteps })... | null | false |
UInt8.mul_succ | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, a * (b + 1) = a * b + a | null | true |
_private.Mathlib.NumberTheory.Fermat.0.Nat.pow_pow_add_primeFactors_one_lt._simp_1_1 | Mathlib.NumberTheory.Fermat | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, (a ∣ b) = ∃ c, b = a * c | null | false |
Std.Internal.List.containsKey_append | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l l' : List ((a : α) × β a)} {a : α},
Std.Internal.List.containsKey a (l ++ l') = (Std.Internal.List.containsKey a l || Std.Internal.List.containsKey a l') | null | true |
ProbabilityTheory.Kernel.bound.eq_1 | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β),
κ.bound = ⨆ a, (κ a) Set.univ | null | true |
Std.ExtTreeSet.get?_diff | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
(t₁ \ t₂).get? k = if k ∈ t₂ then none else t₁.get? k | null | true |
_private.Mathlib.GroupTheory.ClassEquation.0.Group.sum_card_conj_classes_eq_card._simp_1_1 | Mathlib.GroupTheory.ClassEquation | ∀ (G : Type u_1) [inst : Group G] [inst_1 : Fintype (ConjClasses G)] [inst_2 : Fintype G]
[inst_3 : (x : ConjClasses G) → Fintype ↑x.carrier], Fintype.card G = ∑ x, x.carrier.toFinset.card | null | false |
Module.AEval.mapSubmodule._proof_12 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ (R : Type u_2) {A : Type u_3} (M : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (q : Submodule (Polynomial R) (Module.AEval R M a)),
(fun p =>
let __AddSubmonoi... | null | false |
FormalMultilinearSeries.leftInv._proof_27 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], ContinuousConstSMul 𝕜 F | null | false |
SFinKer.instLargeCategory._proof_6 | Mathlib.Probability.Kernel.Category.SFinKer | ∀ {W X Y Z : SFinKer} (κ : W.Hom X) (η : X.Hom Y) (ξ : Y.Hom Z),
{ hom := ξ.hom.comp { hom := η.hom.comp κ.hom, property := ⋯ }.hom, property := ⋯ } =
{ hom := { hom := ξ.hom.comp η.hom, property := ⋯ }.hom.comp κ.hom, property := ⋯ } | null | false |
div_mul_eq_div_div_swap | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a b c : α), a / (b * c) = a / c / b | null | true |
FirstOrder.Language.IsFraisse.FG | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {K : Set (CategoryTheory.Bundled L.Structure)} [self : FirstOrder.Language.IsFraisse K],
∀ M ∈ K, FirstOrder.Language.Structure.FG L ↑M | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLayer._proof_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | ∀ {w : ℕ} (iterNum : ℕ), (iterNum + 1) * w = iterNum * w + w | null | false |
Finsupp.equivMapDomain._proof_3 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_2} {β : Type u_1} {M : Type u_3} [inst : Zero M] (f : α ≃ β) (l : α →₀ M) (a : β),
a ∈ Finset.map f.toEmbedding l.support ↔ l (f.symm a) ≠ 0 | null | false |
Submodule.setLike._proof_1 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p q : Submodule R M), (fun s => s.carrier) p = (fun s => s.carrier) q → p = q | null | false |
IsLocalization.Away.instHMulAwayCoeRingHomAlgebraMap_1 | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (x y : R)
[IsLocalization.Away x S], IsLocalization.Away (x * y) (Localization.Away ((algebraMap R S) y)) | Localizing the localization of `R` at `x` at the image of `y` is the same as localizing
`R` at `x * y`. | true |
StarAlgEquiv.trans._proof_1 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_3} {A : Type u_4} {B : Type u_2} {C : Type u_1} [inst : Add A] [inst_1 : Add B] [inst_2 : Mul A]
[inst_3 : Mul B] [inst_4 : SMul R A] [inst_5 : SMul R B] [inst_6 : Star A] [inst_7 : Star B] [inst_8 : Add C]
[inst_9 : Mul C] [inst_10 : SMul R C] [inst_11 : Star C] (e₁ : A ≃⋆ₐ[R] B) (e₂ : B ≃⋆ₐ[R] C) (r... | null | false |
IsCompl.map | Mathlib.Order.Hom.BoundedLattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : FunLike F α β]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [BoundedLatticeHomClass F α β] {a b : α} (f : F),
IsCompl a b → IsCompl (f a) (f b) | null | true |
instIndiscreteTopologyWithTopologyTopTopologicalSpace | Mathlib.Topology.Order | ∀ {α : Type u}, IndiscreteTopology (WithTopology α ⊤) | null | true |
Lean.Meta.SynthInstance.Answer.mk.noConfusion | Lean.Meta.SynthInstance | {P : Sort u} →
{result : Lean.Meta.AbstractMVarsResult} →
{resultType : Lean.Expr} →
{size : ℕ} →
{result' : Lean.Meta.AbstractMVarsResult} →
{resultType' : Lean.Expr} →
{size' : ℕ} →
{ result := result, resultType := resultType, size := size } =
... | null | false |
Std.DTreeMap.getKeyGT | Std.Data.DTreeMap.AdditionalOperations | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.DTreeMap α β cmp) → (k : α) → (∃ a ∈ t, cmp a k = Ordering.gt) → α | Given a proof that such a mapping exists, retrieves the smallest key that is
greater than the given key.
| true |
MeasureTheory.OuterMeasure.toMeasure_zero | Mathlib.MeasureTheory.Measure.Module | ∀ {α : Type u_1} [mα : MeasurableSpace α] (h : mα ≤ MeasureTheory.OuterMeasure.caratheodory 0),
MeasureTheory.OuterMeasure.toMeasure 0 h = 0 | null | true |
_private.Mathlib.CategoryTheory.Dialectica.Basic.0.CategoryTheory.Dial.«termπ(_,_)» | Mathlib.CategoryTheory.Dialectica.Basic | Lean.ParserDescr | null | true |
MulEquiv.withOneCongr_trans | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Mul α] [inst_1 : Mul β] [inst_2 : Mul γ] (e₁ : α ≃* β) (e₂ : β ≃* γ),
e₁.withOneCongr.trans e₂.withOneCongr = (e₁.trans e₂).withOneCongr | null | true |
IsSymmOp.flip_eq | Mathlib.Logic.OpClass | ∀ {α : Sort u} {β : Sort v} (op : α → α → β) [IsSymmOp op], flip op = op | null | true |
AddOpposite.instNonAssocSemiring | Mathlib.Algebra.Ring.Opposite | {R : Type u_1} → [NonAssocSemiring R] → NonAssocSemiring Rᵃᵒᵖ | null | true |
Set.Finite.eventuallySubset_iInter | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {l : Filter α} {ι : Type u_1} {s : Set ι},
s.Finite → ∀ {f g : ι → Set α}, (∀ i ∈ s, f i ≤ᶠ[l] g i) → ⋂ i ∈ s, f i ≤ᶠ[l] ⋂ i ∈ s, g i | null | true |
UInt32.toUInt64_mod | Init.Data.UInt.Lemmas | ∀ (a b : UInt32), (a % b).toUInt64 = a.toUInt64 % b.toUInt64 | null | true |
ContinuousMultilinearMap.uncurryRight.eq_1 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ {𝕜 : Type u} {n : ℕ} {Ei : Fin n.succ → Type wEi} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : Fin n.succ) → NormedAddCommGroup (Ei i)] [inst_2 : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)]
[inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] (f : Ei i.castSucc [×n]→L[𝕜] Ei (Fin.last n)... | null | true |
Lean.SimplePersistentEnvExtensionDescr.mk.noConfusion | Lean.EnvExtension | {α σ : Type} →
{P : Sort u} →
{name : autoParam Lean.Name Lean.SimplePersistentEnvExtensionDescr.name._autoParam} →
{addEntryFn : σ → α → σ} →
{addImportedFn : Array (Array α) → σ} →
{toArrayFn : List α → Array α} →
{exportEntriesFnEx? : Option (Lean.Environment → σ → List α → ... | null | false |
CategoryTheory.ShortComplex.cyclesMap_smul | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_1} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(φ : S₁ ⟶ S₂) (a : R) [inst_4 : S₁.HasLeftHomology] [inst_5 : S₂.HasLeftHomology],
CategoryTheory... | null | true |
Submodule.IsCompl.projection_ker | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
(hpq : IsCompl p q), (p.projection q hpq).ker = q | **Alias** of `Submodule.ker_projection`. | true |
HomotopicalAlgebra.instModelCategoryOpposite._proof_6 | Mathlib.AlgebraicTopology.ModelCategory.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C],
(HomotopicalAlgebra.cofibrations Cᵒᵖ).IsStableUnderRetracts | null | false |
Lean.Doc.Parser.BlockCtxt._sizeOf_1 | Lean.DocString.Parser | Lean.Doc.Parser.BlockCtxt → ℕ | null | false |
CategoryTheory.Limits.WalkingPair.swap | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.WalkingPair | CategoryTheory.Limits.WalkingPair ≃ CategoryTheory.Limits.WalkingPair | The equivalence swapping left and right.
| true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.V | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option String | null | true |
ModelWithCorners.IsInteriorPoint | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
ModelWithCorners 𝕜 E H → {M : Type u_4} → [inst : TopologicalSpace M] → [Char... | `p ∈ M` is an interior point of a manifold `M` if and only if its image in the extended chart
lies in the interior of the model space. | true |
Array.getElem_zero_filterMap | Init.Data.Array.Find | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {xs : Array α} (h : 0 < (Array.filterMap f xs).size),
(Array.filterMap f xs)[0] = (Array.findSome? f xs).get ⋯ | null | true |
MeasureTheory.FiniteMeasure.normalize._proof_2 | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : Nonempty Ω] {m0 : MeasurableSpace Ω},
MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.dirac inst.some) | null | false |
Set.Ici.codisjoint_iff | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} {a : α} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {x y : ↑(Set.Ici a)},
Codisjoint x y ↔ Codisjoint ↑x ↑y | null | true |
MulAction.toEndHom._proof_2 | Mathlib.Algebra.Group.Action.End | ∀ {M : Type u_2} {α : Type u_1} [inst : Monoid M] [inst_1 : MulAction M α] (x y : M),
(fun x2 => (x * y) • x2) = (fun x2 => x • x2) * fun x2 => y • x2 | null | false |
ZetaAsymptotics.term_nonneg | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ (n : ℕ) (s : ℝ), 0 ≤ ZetaAsymptotics.term n s | null | true |
LieAlgebra.instLieRingOfTwoCocycle._proof_5 | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_3} {L : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
(c : ↥(LieModule.Cohomology.twoCocycle R L M)) (x : LieAlgebra.ofTwoCocycle c),
(LieAlgebra.ofPr... | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.diag_subinterval_eq.match_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (motive : Fin 2 → Prop) (i : Fin 2), (∀ (_ : Unit), motive 0) → (∀ (_ : Unit), motive 1) → motive i | null | false |
Lean.Lsp.InlayHintClientCapabilities.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintClientCapabilities → Sort u} →
(t : Lean.Lsp.InlayHintClientCapabilities) →
((dynamicRegistration? : Option Bool) →
(resolveSupport? : Option Lean.Lsp.ResolveSupport) →
motive { dynamicRegistration? := dynamicRegistration?, resolveSupport? := resolveSupport? }) →
... | null | false |
_private.Std.Sat.CNF.Basic.0.Std.Sat.CNF.Clause.forIn'Impl.go._unsafe_rec | Std.Sat.CNF.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} →
[Monad m] → (c : Std.Sat.CNF.Clause α) → ((l : Std.Sat.Literal α) → l ∈ c → β → m (ForInStep β)) → ℕ → β → m β | null | false |
exists_countable_dense_no_bot_top | Mathlib.Topology.Order.DenselyOrdered | ∀ (α : Type u_1) [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[TopologicalSpace.SeparableSpace α] [Nontrivial α],
∃ s, s.Countable ∧ Dense s ∧ (∀ (x : α), IsBot x → x ∉ s) ∧ ∀ (x : α), IsTop x → x ∉ s | If `α` is a nontrivial separable dense linear order, then there exists a
countable dense set `s : Set α` that contains neither top nor bottom elements of `α`.
For a dense set containing both bot and top elements, see
`exists_countable_dense_bot_top`. | true |
MeasureTheory.IntegrableOn.intervalIntegrable | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] {f : ℝ → ε} {a b : ℝ}
{μ : MeasureTheory.Measure ℝ}, MeasureTheory.IntegrableOn f (Set.uIcc a b) μ → IntervalIntegrable f μ a b | null | true |
_private.Mathlib.NumberTheory.Real.GoldenRatio.0.Real.fibRec_charPoly_eq._simp_1_2 | Mathlib.NumberTheory.Real.GoldenRatio | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, (Polynomial.monomial n) a = a • Polynomial.X ^ n | null | false |
SimpleGraph.CompleteBipartiteGraph.chromaticNumber | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u_4} {W : Type u_5} [Nonempty V] [Nonempty W], (completeBipartiteGraph V W).chromaticNumber = 2 | null | true |
Real.image_exp_Ici | Mathlib.Analysis.SpecialFunctions.Exp | ∀ (a : ℝ), Real.exp '' Set.Ici a = Set.Ici (Real.exp a) | null | true |
CategoryTheory.Discrete.sumEquiv._proof_9 | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_2} {K : Type u_1} (X : CategoryTheory.Discrete (J ⊕ K)),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Discrete.functor fun t =>
match t with
| Sum.inl j => Sum.inl { as := j }
| Sum.inr k => Sum.inr { as := k }).map
((CategoryTheory.NatIso.ofCompo... | null | false |
FirstOrder.Language.LHom.comp_id | Mathlib.ModelTheory.LanguageMap | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (F : L →ᴸ L'), F.comp (FirstOrder.Language.LHom.id L) = F | null | true |
HomologicalComplex.rec | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{c : ComplexShape ι} →
{motive : HomologicalComplex V c → Sort u_2} →
((X : ι → V) →
(d : (i j : ι) → X i ⟶ X j) →
... | null | false |
ContinuousLinearMapWOT.precompCLM._proof_2 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_6} {𝕜₂ : Type u_1} {𝕜₃ : Type u_2} {E : Type u_5} {F : Type u_3} {G : Type u_4} [inst : NormedField 𝕜₁]
[inst_1 : NormedField 𝕜₂] [inst_2 : NormedField 𝕜₃] {σ₁₂ : 𝕜₁ →+* 𝕜₂} {σ₁₃ : 𝕜₁ →+* 𝕜₃} {σ₂₃ : 𝕜₂ →+* 𝕜₃}
[inst_3 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [inst_4 : AddCommGroup E] [inst_5 : To... | null | false |
Polynomial.Monic.irreducible_iff_roots_eq_zero_of_degree_le_three | Mathlib.Algebra.Polynomial.SpecificDegree | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R},
p.Monic → 2 ≤ p.natDegree → p.natDegree ≤ 3 → (Irreducible p ↔ p.roots = 0) | A polynomial of degree 2 or 3 is irreducible iff it doesn't have roots. | true |
Lean.Order.PredTrans.apply_popArg | Std.Internal.Order.PredTrans | ∀ {Pred : Type u} {EPred : Type v} {α : Type w} {σ : Type z} (x : Lean.Order.PredTrans (σ → Pred) EPred α) (s : σ)
(post : α × σ → Pred) (epost : EPred), (x.popArg s).apply post epost = x.apply (fun a s => post (a, s)) epost s | Unfolding `popArg` through `apply`. | true |
Std.Http.Internal.ChunkedBuffer.ctorIdx | Std.Http.Internal.ChunkedBuffer | Std.Http.Internal.ChunkedBuffer → ℕ | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Operations.0.SimpleGraph.disjoint_edge._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u} {G₁ G₂ : SimpleGraph V}, Disjoint G₁ G₂ = Disjoint G₁.edgeSet G₂.edgeSet | null | false |
Filter.Germ.instLeftCancelSemigroup | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {l : Filter α} → {M : Type u_5} → [LeftCancelSemigroup M] → LeftCancelSemigroup (l.Germ M) | null | true |
nhds_vadd | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} {G : Type u_4} [inst : TopologicalSpace α] [inst_1 : AddGroup G] [inst_2 : AddAction G α]
[ContinuousConstVAdd G α] (c : G) (x : α), nhds (c +ᵥ x) = c +ᵥ nhds x | null | true |
NumberField.InfinitePlace.IsUnramified.eq_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ (k : Type u_1) [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K]
(w : NumberField.InfinitePlace K),
NumberField.InfinitePlace.IsUnramified k w = ((w.comap (algebraMap k K)).mult = w.mult) | null | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.ofIsLimitKernelFork._proof_1 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (c₁ : CategoryTheory.Limits.KernelFork S₁.g)
(c₂ : CategoryTheory.Limits.KernelFork S₂.g) (f : c₁.pt ⟶ c₂.pt),
CategoryTheory.CategoryStruct.comp... | null | false |
Submodule.tensorSpanEquivSpan._proof_2 | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ (R : Type u_3) (A : Type u_2) {M : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] [IsScalarTower R A M] (s : Set M),
Submodule.span A ↑(Submodule.span R s) = Submodule.span A s | null | false |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.analyzeAppStagedCore.analyzeArg | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | ℕ → Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeAppM Unit | null | true |
Std.DHashMap.Const.get?_filter | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → Bool} {k : α},
Std.DHashMap.Const.get? (Std.DHashMap.filter f m) k =
(Std.DHashMap.Const.get? m k).pfilter fun x_2 h' => f (m.getKey k ⋯) x_2 | null | true |
Configuration.ProjectivePlane.mk | Mathlib.Combinatorics.Configuration | {P : Type u_1} →
{L : Type u_2} →
[inst : Membership P L] →
[toHasPoints : Configuration.HasPoints P L] →
(mkLine : {p₁ p₂ : P} → p₁ ≠ p₂ → L) →
(∀ {p₁ p₂ : P} (h : p₁ ≠ p₂), p₁ ∈ mkLine h ∧ p₂ ∈ mkLine h) →
(∃ p₁ p₂ p₃ l₁ l₂ l₃, p₁ ∉ l₂ ∧ p₁ ∉ l₃ ∧ p₂ ∉ l₁ ∧ p₂ ∈ l₂ ∧ p₂ ∈ l₃ ... | null | true |
VonNeumannAlgebra.IsIdempotentElem.mem_iff | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] [inst_2 : CompleteSpace H]
{e : H →L[ℂ] H},
IsIdempotentElem e →
∀ (S : VonNeumannAlgebra H),
e ∈ S ↔ ∀ y ∈ S.commutant, (↑e).range ∈ Module.End.invtSubmodule ↑y ∧ (↑e).ker ∈ Module.End.invtSubmodule ↑y | An idempotent is an element in a von Neumann algebra if and only if
its range and kernel are invariant under the commutant. | true |
TopCat.ballInclusion._proof_3 | Mathlib.Topology.Category.TopCat.Sphere | ∀ (n : ℕ) (t : Set (ULift.{u_1, 0} ↑(Metric.closedBall 0 1))) (s : Set ↑(Metric.closedBall 0 1))
(r : Set (EuclideanSpace ℝ (Fin n))),
IsOpen r →
Subtype.val ⁻¹' r = s →
ULift.down ⁻¹' s = t →
IsOpen
((fun x =>
match x with
| { down := ⟨p, hp⟩ } => { down := ⟨... | null | false |
PowerSeries.heval._proof_3 | Mathlib.RingTheory.HahnSeries.HEval | ∀ {Γ : Type u_1} {R : Type u_2} [inst : AddCommMonoid Γ] [inst_1 : LinearOrder Γ] [inst_2 : IsOrderedCancelAddMonoid Γ]
[inst_3 : CommRing R] (x : HahnSeries Γ R), (HahnSeries.SummableFamily.powerSeriesFamily x 1).hsum = 1 | null | false |
HasFTaylorSeriesUpTo.zero_eq | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{f : E → F} {p : E → FormalMultilinearSeries 𝕜 E F}, HasFTaylorSeriesUpTo n f p → ∀ (x : E), (p x ... | null | true |
Equiv.sumAssoc | Mathlib.Logic.Equiv.Sum | (α : Type u_9) → (β : Type u_10) → (γ : Type u_11) → (α ⊕ β) ⊕ γ ≃ α ⊕ β ⊕ γ | Sum of types is associative up to an equivalence. | true |
_private.Init.Data.Fin.Lemmas.0.Fin.instLawfulOrderLT._simp_2 | Init.Data.Fin.Lemmas | ∀ {a b : Prop} [Decidable a], (a → b) = (¬a ∨ b) | null | false |
Vector.set_push | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} {xs : Vector α n} {x y : α} {h : i < n + 1},
(xs.push x).set i y h = if x_1 : i < n then (xs.set i y x_1).push x else xs.push y | null | true |
Std.TreeMap.minKey?_alter_eq_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{f : Option β → Option β}, (t.alter k f).minKey? = some k ↔ (f t[k]?).isSome = true ∧ ∀ k' ∈ t, (cmp k k').isLE = true | null | true |
AnalyticOnNhd.congr' | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F} {s : Set E},
AnalyticOnNhd 𝕜 f s → f =ᶠ[nhdsSet s] g → AnalyticOnNhd 𝕜 g s | null | true |
Localization.localAlgEquiv'_symm_apply | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {P : Type u_3}
[inst_3 : CommSemiring P] (I : Ideal R) [hI : I.IsPrime] [inst_4 : Algebra R P] (J : Ideal S) (K : Ideal P)
[inst_5 : J.IsPrime] [inst_6 : K.IsPrime] [inst_7 : Algebra (Localization.AtPrime I) (Lo... | null | true |
CategoryTheory.fieldEndOfFiniteDimensional._proof_4 | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (𝕜 : Type u_3)
[inst_2 : Field 𝕜] [IsAlgClosed 𝕜] [inst_4 : CategoryTheory.Linear 𝕜 C] [inst_5 : CategoryTheory.Limits.HasKernels C]
(X : C) [inst_6 : CategoryTheory.Simple X] [I : FiniteDimensional 𝕜 (X ⟶ X)... | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Free.Coherence.0.CategoryTheory.FreeMonoidalCategory.normalizeIsoApp'.match_1.splitter | Mathlib.CategoryTheory.Monoidal.Free.Coherence | (C : Type u_1) →
(motive :
CategoryTheory.FreeMonoidalCategory C → CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C → Sort u_2) →
(x : CategoryTheory.FreeMonoidalCategory C) →
(x_1 : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
((a : C) →
(x : CategoryThe... | null | true |
_private.Mathlib.Data.List.Cycle.0.List.next_getLast_cons._proof_1_11 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} (y hd : α) (tl : List α), (y :: hd :: tl).length - 1 < (y :: hd :: tl).length | null | false |
Std.DTreeMap.Internal.Impl.balancedAtRoot_one_two._simp_1 | Std.Data.DTreeMap.Internal.Balanced | Std.DTreeMap.Internal.Impl.BalancedAtRoot 1 2 = True | null | false |
dist_add_dist_of_mem_segment | Mathlib.Analysis.Normed.Affine.Convex | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {x y z : E},
y ∈ segment ℝ x z → dist x y + dist y z = dist x z | null | true |
_private.Lean.Widget.InteractiveCode.0.Lean.Widget.instFromJsonDiffTag.fromJson.match_3 | Lean.Widget.InteractiveCode | (motive : Option String → Sort u_1) →
(x : Option String) → ((tag : String) → motive (some tag)) → (Unit → motive none) → motive x | null | false |
WithTop.zero_eq_coe | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] {a : α}, 0 = ↑a ↔ a = 0 | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr | ∀ {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {w : ℕ}
(cache : Std.Tactic.BVDecide.BVExpr.Cache aig),
Std.Tactic.BVDecide.BVExpr.Cache.Inv assign aig cache →
∀ (expr : Std.Tactic.BVDecide.BVExpr w),
Std.Tactic.BVDecide.BVExpr.Cache.Inv assign
(↑(S... | null | true |
divp_mul_cancel | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (a : α) (u : αˣ), a /ₚ u * ↑u = a | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.