name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.Kernel.comap_apply | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} {g : γ → α} (κ : ProbabilityTheory.Kernel α β) (hg : Measurable g) (c : γ),
(κ.comap g hg) c = κ (g c) | null | true |
Lean.Server.RequestCancellation.recOn | Lean.Server.RequestCancellation | {motive : Lean.Server.RequestCancellation → Sort u} → (t : Lean.Server.RequestCancellation) → motive { } → motive t | null | false |
Std.DTreeMap.Internal.Impl.Const.mem_alter!_of_not_compare_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k k' : α} {f : Option β → Option β},
¬compare k k' = Ordering.eq → (k' ∈ Std.DTreeMap.Internal.Impl.Const.alter! k f t ↔ k' ∈ t) | null | true |
LieAlgebra.SemiDirectSum.instLieRing | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → (ψ : L →ₗ⁅R⁆ LieDerivation R K K) → LieRing (K ⋊⁅ψ⁆ L) | null | true |
Std.DHashMap.Internal.Raw.insert_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} (h : m.WF) {a : α}
{b : β a}, m.insert a b = ↑(Std.DHashMap.Internal.Raw₀.insert ⟨m, ⋯⟩ a b) | null | true |
Algebra.IsTranscendentalSeparable.mk._flat_ctor | Mathlib.FieldTheory.TranscendentalSeparable | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K],
(∀ (L : IntermediateField k K), Algebra.EssFiniteType k ↥L → Algebra.IsSeparablyGenerated k ↥L) →
Algebra.IsTranscendentalSeparable k K | null | false |
Substring.Raw.ValidFor.nextn_stop._f | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} (x : ℕ)
(f :
Nat.below (motive := fun x =>
∀ (x_1 : Substring.Raw),
Substring.Raw.ValidFor l m r x_1 →
x_1.nextn x { byteIdx := String.utf8Len m } = { byteIdx := String.utf8Len m })
x)
(x_1 : Substring.Raw),
Substring.Raw.ValidFor l m r x_1 → x_1.nextn x { b... | null | false |
ZFSet.powersetEquiv | Mathlib.SetTheory.ZFC.Basic | (x : ZFSet.{u}) → ↥x.powerset ≃ ↑(𝒫 ↑x) | `ZFSet.powerset` is equivalent to `Set.powerset`. | true |
_private.Mathlib.Order.RelSeries.0.RelSeries.length_ne_zero._simp_1_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {s : RelSeries r} {x : α}, (x ∈ s) = (x ∈ Set.range s.toFun) | null | false |
SimpleGraph.isClique_compl | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) {s : Set α}, Gᶜ.IsClique s ↔ G.IsIndepSet s | An independent set is a clique in the complement graph and vice versa. | true |
CategoryTheory.AddGrpObj.neg_hom | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.AddGrpObj A] [inst_3 : CategoryTheory.AddGrpObj B] (f : A ⟶ B)
[CategoryTheory.IsAddMonHom f],
CategoryTheory.CategoryStruct.comp CategoryTheory.AddGrpObj.neg f =
... | Morphisms of group objects preserve negations. | true |
bddLat_dual_comp_forget_to_bddOrd | Mathlib.Order.Category.BddLat | BddLat.dual.comp (CategoryTheory.forget₂ BddLat BddOrd) = (CategoryTheory.forget₂ BddLat BddOrd).comp BddOrd.dual | null | true |
Congr!._aux_Mathlib_Tactic_CongrExclamation___elabRules_Congr!_congr!_1 | Mathlib.Tactic.CongrExclamation | Lean.Elab.Tactic.Tactic | null | false |
ZMod.isUnit_inv | Mathlib.Data.ZMod.Units | ∀ {m : ℕ} {n : ℤ}, IsUnit ↑n → IsUnit (↑n)⁻¹ | null | true |
CoxeterMatrix.instGroupGroup._proof_6 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (M : CoxeterMatrix B) (a : M.Group), 1 * a = a | null | false |
CategoryTheory.ProjectiveResolution.instIsGECochainComplexOfNatInt | Mathlib.CategoryTheory.Abelian.Projective.Extend | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C}
(R : CategoryTheory.ProjectiveResolution X), R.cochainComplex.IsGE 0 | null | true |
Std.Async.System.SystemUser.groupId | Std.Async.System | Std.Async.System.SystemUser → Option Std.Async.System.GroupId | The group the user belongs to.
| true |
List.isSome_max?_of_ne_nil | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Max α] {l : List α}, l ≠ [] → l.max?.isSome = true | null | true |
FintypeCat.toLightProfinite._proof_3 | Mathlib.Topology.Category.LightProfinite.Basic | ∀ {X Y Z : FintypeCat} (f : X ⟶ Y) (g : Y ⟶ Z),
CompHausLike.ofHom (fun X => TotallyDisconnectedSpace ↑X ∧ SecondCountableTopology ↑X)
{ toFun := ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)),
continuous_toFun := ⋯ } =
CategoryTheory.CategoryStruct.comp
(CompH... | null | false |
OrderType.instHAdd | Mathlib.Order.Types.Arithmetic | HAdd OrderType.{u} OrderType.{v} OrderType.{max u v} | null | true |
_private.Batteries.Util.ProofWanted.0.WantedRefInfo.deps | Batteries.Util.ProofWanted | WantedRefInfo✝ → Array WantedDep✝ | `nm`'s own non-class wanted-dependencies, to be surfaced as binders on the enclosing
declaration and threaded into `nm`'s application. Empty unless `nm` was itself declared with a
body (or other `❰…❱` references) introducing chained dependencies. | true |
Lean.Compiler.LCNF.FloatLetIn.FloatState.casesOn | Lean.Compiler.LCNF.FloatLetIn | {motive : Lean.Compiler.LCNF.FloatLetIn.FloatState → Sort u} →
(t : Lean.Compiler.LCNF.FloatLetIn.FloatState) →
((decision : Std.HashMap Lean.FVarId Lean.Compiler.LCNF.FloatLetIn.Decision) →
(newArms :
Std.HashMap Lean.Compiler.LCNF.FloatLetIn.Decision
(List (Lean.Compiler.LCNF.C... | null | false |
Cardinal.toNat.eq_1 | Mathlib.Algebra.Module.SpanRank | Cardinal.toNat = ENat.toNatHom.comp ↑↑Cardinal.toENat | null | true |
Std.ExtTreeMap.mk._flat_ctor | Std.Data.ExtTreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : autoParam (α → α → Ordering) Std.ExtTreeMap._auto_1} →
Std.ExtDTreeMap α (fun x => β) cmp → Std.ExtTreeMap α β cmp | null | false |
CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone_π_app_f | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
{T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra}
(c : CategoryTheory.Limits.Cone (D.comp T.forget)) (t : CategoryTheory.Limits.IsLimit c)
[inst_2 : CategoryTheory.Limits.Pr... | null | true |
ciSup_exists | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLinearOrderBot α] {p : ι → Prop} {f : Exists p → α},
⨆ (ih : Exists p), f ih = ⨆ i, ⨆ (h : p i), f ⋯ | null | true |
AlgHom.instContinuousLinearMapClassOfAlgHomClass | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {𝕜 : Type u_1} {A : Type u_2} {F : Type u_3} [inst : NormedField 𝕜] [inst_1 : NormedRing A]
[inst_2 : NormedAlgebra 𝕜 A] [CompleteSpace A] [inst_4 : FunLike F A 𝕜] [AlgHomClass F 𝕜 A 𝕜],
ContinuousLinearMapClass F 𝕜 A 𝕜 | null | true |
Lean.Meta.Grind.Arith.finalizeModel | Lean.Meta.Tactic.Grind.Arith.ModelUtil | Lean.Meta.Grind.Goal →
(Lean.Meta.Grind.ENode → Lean.MetaM Bool) → Std.HashMap Lean.Expr ℚ → Lean.MetaM (Array (Lean.Expr × ℚ)) | Converts the given model into a sorted array of pairs `(e, v)` representing assignments `e := v`.
`isTarget` is a predicate used to detect terms that must be in the model but have not been assigned a value (see: `assignUnassigned`)
The pairs are sorted using `e`s generation and then `Expr.lt`.
Only terms s.t. `isInterp... | true |
List.mem_sublists._simp_1 | Mathlib.Data.List.Sublists | ∀ {α : Type u} {s t : List α}, (s ∈ t.sublists) = s.Sublist t | null | false |
CategoryTheory.Presieve.map_bot | Mathlib.CategoryTheory.Sites.Sieves.Functoriality | ∀ {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 : C}, CategoryTheory.Presieve.map F ⊥ = ⊥ | null | true |
_private.Mathlib.Tactic.FunProp.Theorems.0.Mathlib.Meta.FunProp.instReprLambdaTheoremType.repr.match_1 | Mathlib.Tactic.FunProp.Theorems | (motive : Mathlib.Meta.FunProp.LambdaTheoremType → Sort u_1) →
(x : Mathlib.Meta.FunProp.LambdaTheoremType) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremType.id) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremType.const) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremType.apply) →
... | null | false |
HNNExtension.NormalWord.cons._proof_3 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} {d : HNNExtension.NormalWord.TransversalPair G A B} (u : ℤˣ)
(w : HNNExtension.NormalWord d),
w.head ∈ d.set u →
(∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ HNNExtension.toSubgroup A B u → u = u') →
∀ (u_1 : ℤˣ) (g : G), (u_1, g) ∈ (u, w.head) ... | null | false |
Ordnode.Sized.induction | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} {t : Ordnode α},
t.Sized →
∀ {C : Ordnode α → Prop},
C Ordnode.nil → (∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (l.node' x r)) → C t | null | true |
_private.Mathlib.Geometry.Convex.ConvexSpace.Defs.0.Convexity.StdSimplex.equivIcc._proof_2 | Mathlib.Geometry.Convex.ConvexSpace.Defs | ∀ {R' : Type u_1} [inst : Ring R'] [inst_1 : PartialOrder R'] [IsStrictOrderedRing R'] (t : ↑(Set.Icc 0 1)), 0 ≤ 1 - ↑t | null | false |
StarOrderedRing.rec | Mathlib.Algebra.Order.Star.Basic | {R : Type u_3} →
[inst : NonUnitalSemiring R] →
[inst_1 : PartialOrder R] →
[inst_2 : StarRing R] →
{motive : StarOrderedRing R → Sort u} →
((le_iff : ∀ (x y : R), x ≤ y ↔ ∃ p ∈ AddSubmonoid.closure (Set.range fun s => star s * s), y = x + p) →
motive ⋯) →
(t : St... | null | false |
Function.one_le_const | Mathlib.Algebra.Order.Pi | ∀ {α : Type u_2} {β : Type u_3} [inst : One α] [inst_1 : Preorder α] {a : α} [Nonempty β],
1 ≤ Function.const β a ↔ 1 ≤ a | null | true |
IsSemilinearSet.biInter | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {M : Type u_1} {ι : Type u_3} [inst : AddCommMonoid M] [AddMonoid.FG M] {s : Set ι} {t : ι → Set M},
s.Finite → (∀ i ∈ s, IsSemilinearSet (t i)) → IsSemilinearSet (⋂ i ∈ s, t i) | null | true |
Lean.Lsp.RpcConnectParams._sizeOf_1 | Lean.Data.Lsp.Extra | Lean.Lsp.RpcConnectParams → ℕ | null | false |
Lean.Lsp.Location.recOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.Location → Sort u} →
(t : Lean.Lsp.Location) →
((uri : Lean.Lsp.DocumentUri) → (range : Lean.Lsp.Range) → motive { uri := uri, range := range }) → motive t | null | false |
CategoryTheory.Limits.Cocone.ext._auto_1 | Mathlib.CategoryTheory.Limits.Cones | Lean.Syntax | null | false |
Finset.max_empty | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α], ∅.max = ⊥ | null | true |
Option.pelim_congr_left | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Sort u_2} {o o' : Option α} {b : β} {f : (a : α) → a ∈ o → β} (h : o = o'),
o.pelim b f = o'.pelim b fun a ha => f a ⋯ | null | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int32.instUpwardEnumerable._proof_3 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : Int32), i.toInt + ↑n ≤ Int32.maxValueSealed✝.toInt → i.toInt + ↑n ≤ Int32.maxValue.toInt | null | false |
Monoid.CoprodI.lift._proof_3 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_2} {M : ι → Type u_1} [inst : (i : ι) → Monoid (M i)] {N : Type u_3} [inst_1 : Monoid N]
(fi : (i : ι) → M i →* N) (x x_1 : FreeMonoid ((i : ι) × M i)),
Monoid.CoprodI.Rel M x x_1 ≤ (Con.ker (FreeMonoid.lift fun p => (fi p.fst) p.snd)) x x_1 | null | false |
Setoid.instPartialOrder._proof_2 | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} (x x_1 x_2 : Setoid α), x ≤ x_1 → x_1 ≤ x_2 → ∀ (x_3 x_4 : α), x x_3 x_4 → x_2 x_3 x_4 | null | false |
sInfHom.instPartialOrder | Mathlib.Order.Hom.CompleteLattice | {α : Type u_2} → {β : Type u_3} → [inst : InfSet α] → {x : CompleteLattice β} → PartialOrder (sInfHom α β) | null | true |
Subalgebra.mem_toNonUnitalSubalgebra | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {S : Subalgebra R A}
{x : A}, x ∈ S.toNonUnitalSubalgebra ↔ x ∈ S | null | true |
zpow_left_inj₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : LinearOrder G₀] {a b : G₀} {n : ℤ} [PosMulStrictMono G₀]
[MulPosMono G₀], 0 ≤ a → 0 ≤ b → n ≠ 0 → (a ^ n = b ^ n ↔ a = b) | null | true |
MeasureTheory.Filtration.HasLimitProcess.prodMk | Mathlib.Probability.Process.LimitProcess | ∀ {ι : Type u_1} {Ω : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Preorder ι] {mΩ : MeasurableSpace Ω}
[inst_1 : TopologicalSpace E] [inst_2 : TopologicalSpace F] {P : MeasureTheory.Measure Ω}
{𝓕 : MeasureTheory.Filtration ι mΩ} {X : ι → Ω → E} {Z : ι → Ω → F},
MeasureTheory.Filtration.HasLimitProcess X 𝓕 P... | null | true |
hasFDerivWithinAt_univ._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {f' : E →L[𝕜] F} {x : E},
HasFDerivWithinAt f f' Set.univ x... | null | false |
MonomialOrder.sPolynomial.eq_1 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} (m : MonomialOrder σ) {R : Type u_2} [inst : CommRing R] (f g : MvPolynomial σ R),
m.sPolynomial f g =
(MvPolynomial.monomial (m.degree g - m.degree f)) (m.leadingCoeff g) * f -
(MvPolynomial.monomial (m.degree f - m.degree g)) (m.leadingCoeff f) * g | null | true |
CategoryTheory.Bicategory.InducedBicategory.Hom._mkInternal._flat_ctor | Mathlib.CategoryTheory.Bicategory.InducedBicategory | {B : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Bicategory C] →
{F : B → C} → {X Y : CategoryTheory.Bicategory.InducedBicategory C F} → (F X ⟶ F Y) → X.Hom Y | null | false |
CategoryTheory.ShortComplex.RightHomologyMapData.id._proof_4 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id h.Q) h.g' =
CategoryTheory.CategoryStruct.comp h.g' (CategoryTheo... | null | false |
Finmap.replace._proof_1 | Mathlib.Data.Finmap | ∀ {α : Type u_1} {β : α → Type u_2} [inst : DecidableEq α] (a : α) (b : β a) (x x_1 : AList β),
x.entries.Perm x_1.entries → (AList.replace a b x).toFinmap = (AList.replace a b x_1).toFinmap | null | false |
RingEquiv.prodCongr | Mathlib.Algebra.Ring.Equiv | {R : Type u_7} →
{R' : Type u_8} →
{S : Type u_9} →
{S' : Type u_10} →
[inst : NonUnitalNonAssocSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring R'] →
[inst_2 : NonUnitalNonAssocSemiring S] →
[inst_3 : NonUnitalNonAssocSemiring S'] → R ≃+* R' → S ≃+* S' → R × S ≃... | Product of ring equivalences. This is `Equiv.prodCongr` as a `RingEquiv`. | true |
_private.Mathlib.Analysis.Complex.UnitDisc.Basic.0.Complex.UnitClosedDisc.instIsCancelMulZero._proof_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | IsCancelMulZero Complex.UnitClosedDisc | null | false |
Real.definition._@.Mathlib.Basic.Real.Basic.339334276._hygCtx._hyg.2 | Mathlib.Basic.Real.Basic | ℝ → ℝ | null | false |
TopologicalSpace.Clopens.coe_disjoint | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] {s t : TopologicalSpace.Clopens α}, Disjoint ↑s ↑t ↔ Disjoint s t | null | true |
Aesop.RuleTacDescr.cases.elim | Aesop.RuleTac.Descr | {motive : Aesop.RuleTacDescr → Sort u} →
(t : Aesop.RuleTacDescr) →
t.ctorIdx = 3 →
((target : Aesop.CasesTarget) →
(md : Lean.Meta.TransparencyMode) →
(isRecursiveType : Bool) →
(ctorNames : Array Aesop.CtorNames) →
motive (Aesop.RuleTacDescr.cases target... | null | false |
Lean.Doc.Parser.instReprUnorderedListType.repr | Lean.DocString.Parser | Lean.Doc.Parser.UnorderedListType → ℕ → Std.Format | null | true |
_private.Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four.0.CategoryTheory.Abelian.mono_of_epi_of_epi_mono'._proof_1_1 | Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four | ¬0 + 2 ≤ 2 → False | null | false |
lowerClosure_iUnion | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} {ι : Sort u_3} [inst : Preorder α] (f : ι → Set α), lowerClosure (⋃ i, f i) = ⨆ i, lowerClosure (f i) | null | true |
_private.Lean.Compiler.IR.LLVMBindings.0.Lean.LLVM.Visibility.mk.sizeOf_spec | Lean.Compiler.IR.LLVMBindings | ∀ (val : UInt64), sizeOf { val := val } = 1 + sizeOf val | null | true |
CategoryTheory.PreOneHypercover.inter | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
(E : CategoryTheory.PreOneHypercover S) →
(F : CategoryTheory.PreOneHypercover S) →
[∀ (i : E.I₀) (j : F.I₀), CategoryTheory.Limits.HasPullback (E.f i) (F.f j)] →
[∀ (i j : E.I₀) (k : E.I₁ i j) (a b : F.I₀) (l... | Intersection of two pre-`1`-hypercovers. | true |
NonemptyInterval.instLinearOrderLex | Mathlib.Order.Interval.Lex | {α : Type u_1} → [inst : LinearOrder α] → LinearOrder (Lex (NonemptyInterval α)) | null | true |
WithVal.ctorIdx | Mathlib.Topology.Algebra.Valued.WithVal | {R : Type u_1} →
{Γ₀ : Type u_2} →
{inst : LinearOrderedCommGroupWithZero Γ₀} → {inst_1 : Ring R} → {v : Valuation R Γ₀} → WithVal v → ℕ | null | false |
RelIso.default_def | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} (r : α → α → Prop), default = RelIso.refl r | null | true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exist_disjoint_covering_families._simp_1_11 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | null | false |
Qq.Impl.MVarSynth.type.noConfusion | Qq.Macro | {P : Sort u} →
{unquotedMVar unquotedMVar' : Lean.MVarId} →
Qq.Impl.MVarSynth.type unquotedMVar = Qq.Impl.MVarSynth.type unquotedMVar' → (unquotedMVar = unquotedMVar' → P) → P | null | false |
CommSemigroup.noConfusion | Mathlib.Algebra.Group.Semigroup | {P : Sort u} →
{G : Type u_2} →
{t : CommSemigroup G} →
{G' : Type u_2} → {t' : CommSemigroup G'} → G = G' → t ≍ t' → CommSemigroup.noConfusionType P t t' | null | false |
_private.Mathlib.RingTheory.Etale.Field.0.Algebra.FormallyEtale.equivPiOfIsSepClosed._proof_4 | Mathlib.RingTheory.Etale.Field | ∀ (K : Type u_2) (A : Type u_1) [inst : Field K] [inst_1 : CommRing A] [inst_2 : Algebra K A]
[Algebra.EssFiniteType K A] [Algebra.FormallyEtale K A], IsArtinian A A | null | false |
closure_subset_mul_self_of_mem_nhds_one | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] {U : Set G},
U ∈ nhds 1 → closure U ⊆ U * U | null | true |
SimpleGraph._aux_Mathlib_Combinatorics_SimpleGraph_Prod___unexpand_SimpleGraph_boxProd_1 | Mathlib.Combinatorics.SimpleGraph.Prod | Lean.PrettyPrinter.Unexpander | null | false |
CommMonCat.instCoeMonCat.eq_1 | Mathlib.Algebra.Category.MonCat.Basic | CommMonCat.instCoeMonCat = { coe := (CategoryTheory.forget₂ CommMonCat MonCat).obj } | null | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.prod_Iic_div._proof_1_16 | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_1} [inst : CommGroup M] {n : ℕ} (a : Fin n) (f : Fin (n + 1) → M),
f a.succ / f 0 = (if hi : ↑a + 1 < n + 1 then f ⟨↑a + 1, hi⟩ else 1) / if hi : 0 < n + 1 then f ⟨0, hi⟩ else 1 | null | false |
TensorProduct.equivOfCompatibleSMul._proof_5 | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] (A : Type u_4) (S : Type u_5) (M : Type u_2) (N : Type u_3)
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N]
[inst_5 : CommSemiring A] [inst_6 : Module A M] [inst_7 : Module A N] [inst_8 : SMulCommClass R A M]
[inst_9 : Comm... | null | false |
Set.iUnion_sum | Mathlib.Data.Set.Lattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : α ⊕ β → Set γ}, ⋃ x, s x = (⋃ x, s (Sum.inl x)) ∪ ⋃ x, s (Sum.inr x) | null | true |
String.Pos.utf8ByteSize_byte | Init.Data.String.Basic | ∀ {s : String} {pos : s.Pos} {h : pos ≠ s.endPos}, (pos.byte h).utf8ByteSize ⋯ = (pos.get h).utf8Size | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.maxKeyD_modify_eq_maxKeyD._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
CFC.nnrpow._proof_2 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : Module ℝ A] [IsScalarTower ℝ A A], IsScalarTower NNReal A A | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk._proof_7 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (k i : ℕ), i + k + 1 ≤ n → ¬i + k ≤ n → False | null | false |
Lean.Elab.Tactic.Omega.Justification.toString._f | Lean.Elab.Tactic.Omega.Core | {s : Lean.Omega.Constraint} →
{x : Lean.Omega.Coeffs} →
(x_1 : Lean.Elab.Tactic.Omega.Justification s x) → Lean.Elab.Tactic.Omega.Justification.below x_1 → String | null | false |
dec_em' | Mathlib.Basic.Logic.Basic | ∀ (p : Prop) [Decidable p], ¬p ∨ p | null | true |
ULift.mulOneClass.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : MulOneClass α], ULift.mulOneClass = Function.Injective.mulOneClass ⇑Equiv.ulift ⋯ ⋯ ⋯ | null | true |
_private.Init.Data.Vector.Lemmas.0.Vector.map_inj._simp_1_3 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {a b : α} {n : ℕ}, (b ∈ Array.replicate n a) = (n ≠ 0 ∧ b = a) | null | false |
AddHomClass.toAddHom.congr_simp | Mathlib.Algebra.DirectSum.Module | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[inst_3 : AddHomClass F M N] (f f_1 : F), f = f_1 → ↑f = ↑f_1 | null | true |
ImportGraph.Widget.RpcEncodablePacket.«_@».ImportGraph.Widget.Copy.3915609200._hygCtx._hyg.1.recOn | ImportGraph.Widget.Copy | {motive : ImportGraph.Widget.RpcEncodablePacket✝ → Sort u} →
(t : ImportGraph.Widget.RpcEncodablePacket✝) →
((display copyText hasIcon : Lean.Json) → motive { display := display, copyText := copyText, hasIcon := hasIcon }) →
motive t | null | false |
_private.Mathlib.Algebra.Homology.Embedding.Boundary.0.ComplexShape.Embedding.not_boundaryGE_next._simp_1_2 | Mathlib.Algebra.Homology.Embedding.Boundary | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
List.allSome | Batteries.Data.List.Basic | {α : Type u_1} → List (Option α) → Option (List α) | If all elements of `xs` are `some xᵢ`, `allSome xs` returns the `xᵢ`. Otherwise
it returns `none`.
```
allSome [some 1, some 2] = some [1, 2]
allSome [some 1, none ] = none
```
| true |
Lean.Syntax.Traverser.mk._flat_ctor | Lean.Syntax | Lean.Syntax → Array Lean.Syntax → Array ℕ → Lean.Syntax.Traverser | null | false |
Batteries.Tactic.Alias.AliasInfo.reverse.elim | Batteries.Tactic.Alias | {motive : Batteries.Tactic.Alias.AliasInfo → Sort u} →
(t : Batteries.Tactic.Alias.AliasInfo) →
t.ctorIdx = 2 → ((n : Lean.Name) → motive (Batteries.Tactic.Alias.AliasInfo.reverse n)) → motive t | null | false |
BoundedContinuousFunction.instNonUnitalNormedCommRing._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_2} [inst_1 : NonUnitalNormedCommRing R]
(a b : BoundedContinuousFunction α R), a * b = b * a | null | false |
Lean.Compiler.LCNF.instDecidableLtPhase | Lean.Compiler.LCNF.PassManager | {p1 p2 : Lean.Compiler.LCNF.Phase} → Decidable (p1 < p2) | null | true |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processCtorAppContext.match_1 | Lean.Elab.PatternVar | (motive : Lean.BinderInfo → Sort u_1) →
(x : Lean.BinderInfo) →
(Unit → motive Lean.BinderInfo.implicit) →
(Unit → motive Lean.BinderInfo.strictImplicit) →
(Unit → motive Lean.BinderInfo.instImplicit) → ((x : Lean.BinderInfo) → motive x) → motive x | null | false |
AlgebraicGeometry.Scheme.AffineZariskiSite.toOpens_mono | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme}, Monotone AlgebraicGeometry.Scheme.AffineZariskiSite.toOpens | null | true |
AnalyticAt.eventually_analyticAt | Mathlib.Analysis.Analytic.ChangeOrigin | ∀ {𝕜 : 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] [CompleteSpace F] {f : E → F}
{x : E}, AnalyticAt 𝕜 f x → ∀ᶠ (y : E) in nhds x, AnalyticAt 𝕜 f y | null | true |
LieSubmodule.idealizer._proof_1 | Mathlib.Algebra.Lie.Normalizer | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M) {x y : L},
x ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → y ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → ∀ (m : M), ⁅x + y, m⁆ ∈ N | null | false |
Std.DTreeMap.Internal.Impl.insertMax | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
(k : α) → β k → (t : Std.DTreeMap.Internal.Impl α β) → t.Balanced → Std.DTreeMap.Internal.Impl.Tree α β (t.size + 1) | Inserts an element at the end of the tree. | true |
_private.Std.Data.DTreeMap.Internal.Balanced.0.Std.DTreeMap.Internal.Impl.balancedAtRoot_one_zero._proof_1_1 | Std.Data.DTreeMap.Internal.Balanced | ¬(1 + 0 ≤ 1 ∨ 1 ≤ Std.DTreeMap.Internal.delta * 0 ∧ 0 ≤ Std.DTreeMap.Internal.delta * 1) → False | null | false |
CategoryTheory.FreeMonoidalCategory.project._proof_1 | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} D]
[inst_1 : CategoryTheory.MonoidalCategory D] (f : C → D) (X : CategoryTheory.FreeMonoidalCategory C),
CategoryTheory.FreeMonoidalCategory.projectMap f X X (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id (Catego... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.