name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.IterM.DefaultConsumers.forIn'_eq_wf | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {m : Type w → Type w'} {α β : Type w} [inst : Std.Iterator α m β] {n : Type x → Type x'} [inst_1 : Monad n]
[LawfulMonad n] {lift : (γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ} {γ : Type x}
(Pl : β → γ → ForInStep γ → Prop) (wf : Std.IteratorLoop.WellFounded α m Pl) {it : Std.IterM m β} {init : γ}
{P : ... | null | true |
_private.Mathlib.Analysis.BoxIntegral.Integrability.0.BoxIntegral.HasIntegral.of_aeEq_zero._simp_1_1 | Mathlib.Analysis.BoxIntegral.Integrability | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.TaggedPrepartition I) {x : ι → ℝ},
(x ∈ π.iUnion) = ∃ J ∈ π, x ∈ J | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.forIn_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Lean.Parser.Module.import.formatter | Lean.Parser.Module.Syntax | Lean.PrettyPrinter.Formatter | null | true |
_private.Mathlib.AlgebraicTopology.Reedy.Basic.0.HomotopicalAlgebra.ReedyStructure.degHom_comp_le_left.match_1_1 | Mathlib.AlgebraicTopology.Reedy.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
[inst_1 : W₁.IsMultiplicative] [inst_2 : W₂.IsMultiplicative] {α : Type u_3} [inst_3 : LinearOrder α]
[inst_4 : OrderBot α] [inst_5 : SuccOrder α] [inst_6 : WellFoundedLT α]
(r : HomotopicalAlgebra.ReedyStru... | null | false |
Function.rightInverse_iff_comp | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α}, Function.RightInverse f g ↔ g ∘ f = id | null | true |
MeasureTheory.eLpNorm'_const | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {ε' : Type u_3} {m0 : MeasurableSpace α} {q : ℝ} {μ : MeasureTheory.Measure α} [inst : ENorm ε']
(c : ε'), 0 < q → MeasureTheory.eLpNorm' (fun x => c) q μ = ‖c‖ₑ * μ Set.univ ^ (1 / q) | null | true |
Lean.Grind.CommRing.instLawfulBEqPower | Init.Grind.Ring.CommSolver | LawfulBEq Lean.Grind.CommRing.Power | null | true |
Lake.GetMTime.rec | Lake.Build.Trace | {α : Type u} →
{motive : Lake.GetMTime α → Sort u_1} →
((getMTime : α → IO Lake.MTime) → motive { getMTime := getMTime }) → (t : Lake.GetMTime α) → motive t | null | false |
_private.Mathlib.Data.List.OfFn.0.List.find?_ofFn_eq_some_of_injective._simp_1_1 | Mathlib.Data.List.OfFn | ∀ {α : Type u} {n : ℕ} {f : Fin n → α} {p : α → Bool} {b : α},
(List.find? p (List.ofFn f) = some b) = (p b = true ∧ ∃ i, f i = b ∧ ∀ j < i, ¬p (f j) = true) | null | false |
CategoryTheory.functorProdFunctorEquiv_counitIso | Mathlib.CategoryTheory.Products.Basic | ∀ (A : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
(C : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} C],
(CategoryTheory.functorProdFunctorEquiv A B C).counitIso = CategoryTheory.functorProdFunctorEquivCounitIso A B C | null | true |
Lake.BuildTrace.noConfusion | Lake.Build.Trace | {P : Sort u} → {t t' : Lake.BuildTrace} → t = t' → Lake.BuildTrace.noConfusionType P t t' | null | false |
Lean.Meta.ReduceMatcherResult.reduced.inj | Lean.Meta.WHNF | ∀ {val val_1 : Lean.Expr},
Lean.Meta.ReduceMatcherResult.reduced val = Lean.Meta.ReduceMatcherResult.reduced val_1 → val = val_1 | null | true |
_private.Mathlib.Analysis.Fourier.Inversion.0.Real.tendsto_integral_cexp_sq_smul._simp_1_2 | Mathlib.Analysis.Fourier.Inversion | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] {a : α}, (-a ≤ 0) = (0 ≤ a) | null | false |
CategoryTheory.Pretriangulated.Opposite.commShiftFunctorOpInt | Mathlib.CategoryTheory.Triangulated.Opposite.Functor | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[inst_3 : CategoryTheory.HasShift D ℤ] → (F : CategoryTheory.Functor C D) → [F.CommShift ℤ] → F.op.CommShift ℤ | If `F` commutes with shifts, so does `F.op`, for the shifts chosen on `Cᵒᵖ` in
`CategoryTheory.Triangulated.Opposite.Basic`.
| true |
Std.DTreeMap.Internal.Impl.Balanced.leaf._simp_1 | Std.Data.DTreeMap.Internal.Balanced | ∀ {α : Type u} {β : α → Type v}, Std.DTreeMap.Internal.Impl.leaf.Balanced = True | null | false |
CategoryTheory.Limits.PreservesLimitsOfSize.preservesLimitsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : CategoryTheory.Functor C D} [self : CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J], CategoryTheory.Limits.Pre... | null | true |
mulRightLinearMap_eq_zero_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.Bilinear | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {R : Type u_5} {A : Type u_6} [inst : Fintype m] [inst_1 : Semiring R]
[inst_2 : Semiring A] [inst_3 : Module R A] [inst_4 : IsScalarTower R A A] (a : Matrix m n A) [Nonempty l],
(mulRightLinearMap l R a = 0) = (a = 0) | null | false |
_private.Mathlib.Combinatorics.Enumerative.Bell.0.Multiset.bell_cons_mul_count._simp_1_5 | Mathlib.Combinatorics.Enumerative.Bell | ∀ (i j : ℕ), (i + j).factorial = (i + j).choose j * i.factorial * j.factorial | null | false |
Nat.xor_mod_two_pow | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b n : ℕ}, (a ^^^ b) % 2 ^ n = a % 2 ^ n ^^^ b % 2 ^ n | null | true |
AlgebraicGeometry.Scheme.Modules.sheafComposePushforwardComp._proof_2 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {R : CommRingCat},
(Opens.grothendieckTopology ↥(AlgebraicGeometry.Spec R)).HasSheafCompose
(ModuleCat.restrictScalars (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.ΓSpecIso R).inv)) | null | false |
Mathlib.Tactic.Order.Edge.mk._flat_ctor | Mathlib.Tactic.Order.Graph.Basic | ℕ → ℕ → Lean.Expr → Mathlib.Tactic.Order.Edge | null | false |
AddOpposite.instDivisionSemiring._proof_9 | Mathlib.Algebra.Field.Opposite | ∀ {α : Type u_1} [inst : DivisionSemiring α] (q : ℚ≥0), ↑q = ↑q.num / ↑q.den | null | false |
Set.Iic_ofDual | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {x : αᵒᵈ}, Set.Iic (OrderDual.ofDual x) = ⇑OrderDual.toDual ⁻¹' Set.Ici x | null | true |
Equiv.generalizedBooleanAlgebra._proof_2 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : GeneralizedBooleanAlgebra β] {x y : α}, e x < e y ↔ e x < e y | null | false |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.splitRevInTwo'._proof_3 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} {n : ℕ} (l : { l // l.length = n }), (List.MergeSort.Internal.splitRevAt (n / 2) ↑l).1.length = n / 2 | null | false |
_private.Mathlib.Data.List.MinMax.0.List.argmax_cons._proof_1_4 | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder β] (f : α → β) (a tl m : α),
¬f a < f m →
¬f m < f tl →
Option.rec (some tl) (fun val => if f val < f tl then some tl else some val) (some a) =
Option.rec (some a) (fun val => if f a < f val then some val else some a) (some m) | null | false |
AddAction.prodOfVAddCommClass | Mathlib.Algebra.Group.Action.Prod | (M : Type u_1) →
(N : Type u_2) →
(α : Type u_4) →
[inst : AddMonoid M] →
[inst_1 : AddMonoid N] →
[inst_2 : AddAction M α] → [inst_3 : AddAction N α] → [VAddCommClass M N α] → AddAction (M × N) α | Construct an `AddAction` by a product monoid from `AddAction`s by the factors.
This is not an instance to avoid diamonds for example when `α := M × N`. | true |
Lean.Lsp.WindowClientCapabilities.noConfusionType | Lean.Data.Lsp.Capabilities | Sort u → Lean.Lsp.WindowClientCapabilities → Lean.Lsp.WindowClientCapabilities → Sort u | null | false |
Prime.exists_mem_multiset_dvd | Mathlib.Algebra.BigOperators.Associated | ∀ {M₀ : Type u_3} [inst : CommMonoidWithZero M₀] {p : M₀}, Prime p → ∀ {s : Multiset M₀}, p ∣ s.prod → ∃ a ∈ s, p ∣ a | null | true |
_private.Mathlib.ModelTheory.Order.0.FirstOrder.Language.dlo_isComplete._simp_1_1 | Mathlib.ModelTheory.Order | (1 ≤ Cardinal.aleph0) = True | null | false |
Mathlib.Tactic.Bicategory.Context.ctorIdx | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Mathlib.Tactic.Bicategory.Context → ℕ | null | false |
CategoryTheory.Limits.StrongEpiMonoFactorisation.toMonoIsImage._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}
(F : CategoryTheory.Limits.StrongEpiMonoFactorisation f) (F' : CategoryTheory.Limits.MonoFactorisation f),
CategoryTheory.CategoryStruct.comp ⋯.lift F'.m = F.m | null | false |
Continuous.nsmul | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M] [inst_2 : AddMonoid M]
[ContinuousAdd M] {f : X → M}, Continuous f → ∀ (n : ℕ), Continuous (n • f) | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rii.mem_iff_mem_rci._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.Least? α]
[inst_2 : Std.PRange.LawfulUpwardEnumerableLeast? α] {a : α},
Std.PRange.UpwardEnumerable.LE Std.PRange.UpwardEnumerable.least a = True | null | false |
Lean.LLVM.buildGEP2 | Lean.Compiler.IR.LLVMBindings | {ctx : Lean.LLVM.Context} →
Lean.LLVM.Builder ctx →
Lean.LLVM.LLVMType ctx →
Lean.LLVM.Value ctx → Array (Lean.LLVM.Value ctx) → optParam String "" → BaseIO (Lean.LLVM.Value ctx) | null | true |
_private.Lean.Data.SMap.0.Lean.SMap.insert.match_1 | Lean.Data.SMap | {α : Type u_1} →
{β : Type u_2} →
[inst : BEq α] →
[inst_1 : Hashable α] →
(motive : Lean.SMap α β → α → β → Sort u_3) →
(x : Lean.SMap α β) →
(x_1 : α) →
(x_2 : β) →
((m₁ : Std.HashMap α β) →
(m₂ : Lean.PHashMap α β) → (k : α) ... | null | false |
SemimoduleCat.rec | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u} →
[inst : Semiring R] →
{motive : SemimoduleCat R → Sort u_1} →
((carrier : Type v) →
[isAddCommMonoid : AddCommMonoid carrier] →
[isModule : Module R carrier] →
motive { carrier := carrier, isAddCommMonoid := isAddCommMonoid, isModule := isModule }) →
... | null | false |
PartOrd.hom_id | Mathlib.Order.Category.PartOrd | ∀ {X : PartOrd}, PartOrd.Hom.hom (CategoryTheory.CategoryStruct.id X) = OrderHom.id | null | true |
Complex.ECanonicalDecomp.mk | Mathlib.Analysis.Complex.CanonicalDecomposition | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f g : ℂ → E} {R : ℝ},
MeromorphicOn f (Metric.closedBall 0 R) →
AnalyticOnNhd ℂ g (Metric.closedBall 0 R) →
(∀ u ∈ Metric.closedBall 0 R, g u ≠ 0) →
f =ᶠ[Filter.codiscreteWithin (Metric.closedBall 0 R)]
((∏ᶠ (u : ... | null | true |
Float.Model.UnpackedFloat.unpackMantissa_packComponents | Init.Data.Float.Model.Unpacked.Pack.Lemmas | ∀ {spec : Float.Model.Format} {sign : Float.Model.UnpackedFloat.Sign} {exponent : BitVec spec.exponentBits}
{mantissa : BitVec spec.mantissaBitsWithoutImplicit},
Float.Model.UnpackedFloat.unpackMantissa (Float.Model.UnpackedFloat.packComponents spec sign exponent mantissa) =
mantissa | null | true |
PadicComplexInt._proof_2 | Mathlib.NumberTheory.Padics.Complex | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], CompletableTopField (PadicAlgCl p) | null | false |
CategoryTheory.GrothendieckTopology.Cover.oneHypercover._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
(S : J.Cover X), S.preOneHypercover.sieve₀ ∈ J X | null | false |
sSup_sUnion | Mathlib.Data.Set.Lattice.Order | ∀ {β : Type u_2} [inst : CompleteLattice β] (s : Set (Set β)), sSup (⋃₀ s) = ⨆ t ∈ s, sSup t | null | true |
_private.Lean.Meta.Sym.Offset.0.Lean.Meta.Sym.toOffset.match_1 | Lean.Meta.Sym.Offset | (motive : OptionT Id ℕ → Sort u_1) →
(x : OptionT Id ℕ) → ((n : ℕ) → motive (some n)) → ((x : OptionT Id ℕ) → motive x) → motive x | null | false |
_private.Mathlib.Algebra.Category.ModuleCat.Biproducts.0.lequivProdOfRightSplitExact'._simp_1 | Mathlib.Algebra.Category.ModuleCat.Biproducts | ∀ {R : Type u} [inst : Ring R] {X Y : ModuleCat R} (f : X ⟶ Y),
CategoryTheory.Mono f = Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom f) | null | false |
exteriorPower.basis_repr | Mathlib.LinearAlgebra.ExteriorPower.Basis | ∀ (R : Type u_1) {M : Type u_3} (n : ℕ) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{I : Type u_5} [inst_3 : LinearOrder I] (b : Module.Basis I R M) (s : ↑(Set.powersetCard I n)),
(Module.Basis.exteriorPower n b).repr (exteriorPower.ιMulti_family R n (⇑b) s) = fun₀ | s => 1 | null | true |
frattini_le_coatom | Mathlib.GroupTheory.Frattini | ∀ {G : Type u_1} [inst : Group G] {K : Subgroup G}, IsCoatom K → frattini G ≤ K | null | true |
SSet.Subcomplex.unionProd.symmIso_hom | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | ∀ {X Y : SSet} (S : X.Subcomplex) (T : Y.Subcomplex),
(SSet.Subcomplex.unionProd.symmIso S T).hom =
SSet.Subcomplex.lift (CategoryTheory.CategoryStruct.comp (S.unionProd T).ι (β_ X Y).hom) ⋯ | null | true |
ULift.seminormedRing._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] (a b : ULift.{u_1, u_2} α), a - b = a + -b | null | false |
Std.WP.Spec.tryCatch_ExceptT_lift.match_1 | Std.WP.Triple.SpecLemmas | {ε' α : Type u_1} →
(motive : Except ε' α → Sort u_2) →
(x : Except ε' α) → ((a : α) → motive (Except.ok a)) → ((e : ε') → motive (Except.error e)) → motive x | null | false |
_private.Mathlib.Order.WithBot.0.WithBot.decidableLT.match_1.eq_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} (motive : WithBot α → WithBot α → Sort u_2) (x : WithBot α) (h_1 : (x : WithBot α) → motive x none)
(h_2 : (a : α) → motive none (some a)) (h_3 : (a b : α) → motive (some a) (some b)),
(match x, none with
| x, none => h_1 x
| none, some a => h_2 a
| some a, some b => h_3 a b) =
h_1 ... | null | true |
min_inv_inv_le | Mathlib.Algebra.Order.Group.MinMax | ∀ {G₀ : Type u_1} [inst : Inv G₀] [inst_1 : LinearOrder G₀] {x y : G₀}, min x⁻¹ y⁻¹ ≤ (max x y)⁻¹ | null | true |
dotProductEquiv_symm_apply | Mathlib.LinearAlgebra.Matrix.Dual | ∀ (R : Type u_1) (n : Type u_2) [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n]
(f : Module.Dual R (n → R)) (i : n), (dotProductEquiv R n).symm f i = f ((LinearMap.single R (fun a => R) i) 1) | null | true |
instNonUnitalCommCStarAlgebraProd._proof_9 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} {B : Type u_2} [inst : NonUnitalCommCStarAlgebra A] [inst_1 : NonUnitalCommCStarAlgebra B] (a : A × B),
a * 0 = 0 | null | false |
Commute.units_inv_right | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : Monoid M] {a : M} {u : Mˣ}, Commute a ↑u → Commute a ↑u⁻¹ | null | true |
Std.Internal.List.keys_eq_map | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} {l : List ((a : α) × β a)}, Std.Internal.List.keys l = List.map (fun x => x.fst) l | null | true |
Nat.Prime.dvd_choose_self | Mathlib.Data.Nat.Choose.Dvd | ∀ {p k : ℕ}, Nat.Prime p → k ≠ 0 → k < p → p ∣ p.choose k | null | true |
SimpleGraph.mulCayley_empty | Mathlib.Combinatorics.SimpleGraph.Cayley | ∀ {M : Type u_1} [inst : Mul M], SimpleGraph.mulCayley ∅ = ⊥ | null | true |
MapClusterPt.tendsto_comp | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {Y : Type v} {α : Type u_1} {F : Filter α} {u : α → X} {x : X}
[inst_1 : TopologicalSpace Y] {f : X → Y} {y : Y},
Filter.Tendsto f (nhds x) (nhds y) → MapClusterPt x F u → MapClusterPt y F (f ∘ u) | null | true |
Lean.Elab.InfoState.rec | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.InfoState → Sort u} →
((enabled : Bool) →
(assignment : Lean.PersistentHashMap Lean.MVarId Lean.Elab.InfoTree) →
(lazyAssignment : Lean.PersistentHashMap Lean.MVarId (Task Lean.Elab.InfoTree)) →
(trees : Lean.PersistentArray Lean.Elab.InfoTree) →
motive { enable... | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.withLocalDecls.loop._unsafe_rec | Lean.Meta.Basic | {n : Type → Type u_1} →
[MonadControlT Lean.MetaM n] →
[Monad n] →
{α : Type} →
Array (Lean.Name × Lean.BinderInfo × (Array Lean.Expr → n Lean.Expr)) →
(Array Lean.Expr → n α) → Lean.LocalDeclKind → [Inhabited α] → Array Lean.Expr → n α | null | false |
MonadWriter.mk | Mathlib.Control.Monad.Writer | {ω : outParam (Type u)} →
{M : Type u → Type v} →
(ω → M PUnit.{u + 1}) → ({α : Type u} → M α → M (α × ω)) → ({α : Type u} → M (α × (ω → ω)) → M α) → MonadWriter ω M | null | true |
CategoryTheory.Oplax.LaxTrans.Modification.id_app | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (η : F ⟶ G) (a : B),
(CategoryTheory.Oplax.LaxTrans.Modification.id η).app a = CategoryTheory.CategoryStruct.id (η.app a) | null | true |
CategoryTheory.PreZeroHypercover.sectionsSaturateEquiv._proof_4 | Mathlib.CategoryTheory.Sites.Hypercover.Saturate | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.Functor Cᵒᵖ (Type u_1)) (x : (E.saturate.multicospanIndex F).sections),
{ val := ↑⟨x.val, ⋯⟩, property := ⋯ } = { val := ↑⟨x.val, ⋯⟩, property := ⋯ } | null | false |
_private.Mathlib.CategoryTheory.Limits.Indization.FilteredColimits.0.CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux._aux_Mathlib_CategoryTheory_Limits_Indization_FilteredColimits___macroRules__private_Mathlib_CategoryTheory_Limits_Indization_FilteredColimits_0_CategoryTheory_Limits_IndizationClosedUnder... | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | Lean.Macro | null | false |
Lean.LLVM.Context.noConfusion | Lean.Compiler.IR.LLVMBindings | {P : Sort u} → {t t' : Lean.LLVM.Context} → t = t' → Lean.LLVM.Context.noConfusionType P t t' | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_eq_none_of_contains_eq_false._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
MvPolynomial.mem_support_iff | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {m : σ →₀ ℕ}, m ∈ p.support ↔ p.coeff m ≠ 0 | null | true |
Lean.Grind.CommRing.Expr.toPoly.match_4.congr_eq_5 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (x : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_3 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (Lea... | null | true |
CategoryTheory.Bicategory.RightAdjoint.ctorIdx | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} → {a b : B} → {left : a ⟶ b} → CategoryTheory.Bicategory.RightAdjoint left → ℕ | null | false |
RingHom.prod._proof_2 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S],
AddMonoidHomClass (R →+* S) R S | null | false |
Fin.val_min | Init.Data.Fin.MinMax | ∀ {n : ℕ} (a b : Fin n), ↑(min a b) = min ↑a ↑b | null | true |
IsSimpleGroup.prime_card | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {α : Type u_1} [inst : CommGroup α] [IsSimpleGroup α], Nat.Prime (Nat.card α) | null | true |
Lean.Meta.setPostponed | Lean.Meta.Basic | Lean.PersistentArray Lean.Meta.PostponedEntry → Lean.MetaM Unit | Set the array of postponed universe level constraints. | true |
_private.Mathlib.Tactic.GCongr.Core.0.Lean.MVarId.gcongr.match_7 | Mathlib.Tactic.GCongr.Core | (motive : ℕ → Sort u_1) → (depth : ℕ) → ((depth : ℕ) → motive depth.succ) → ((x : ℕ) → motive x) → motive depth | null | false |
ProbabilityTheory.Kernel.iIndepFun.indepFun_sub_sub | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : Type u_8} {m : MeasurableSpace β} [inst : Sub β]
[MeasurableSub₂ β] {f : ι → Ω → β},
ProbabilityTheory.Kernel.iIndepFun f κ μ →
(∀ (i : ι), Mea... | null | true |
_private.Mathlib.Algebra.Group.Units.Defs.0.isUnit_iff_exists.match_1_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : Monoid M] {x : M} (motive : IsUnit x → Prop) (x_1 : IsUnit x),
(∀ (u : Mˣ) (hu : ↑u = x), motive ⋯) → motive x_1 | null | false |
disjointed | Mathlib.Order.Disjointed | {α : Type u_1} →
{ι : Type u_2} → [GeneralizedBooleanAlgebra α] → [inst : Preorder ι] → [LocallyFiniteOrderBot ι] → (ι → α) → ι → α | The function mapping `i` to `f i \ (⨆ j < i, f j)`. When `ι` is a partial order, this is the
unique function `g` having the same `partialSups` as `f` and such that `g i` and `g j` are
disjoint whenever `i < j`. | true |
of_addIrreducible_add | Mathlib.Algebra.Group.Irreducible.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {a b : M}, AddIrreducible (a + b) → IsAddUnit a ∨ IsAddUnit b | null | true |
FirstOrder.Language.Sentence.realize_imp._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} (M : Type w) [inst : L.Structure M] {φ ψ : L.Sentence},
M ⊨ FirstOrder.Language.Formula.imp φ ψ = (M ⊨ φ → M ⊨ ψ) | null | false |
CategoryTheory.ShortComplex.LeftHomologyMapData.op._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₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : S₁.LeftHomologyData} {h₂ : S₂.LeftHomologyData}
(ψ : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁ h₂),
CategoryTheory.CategoryStruc... | null | false |
FirstOrder.Language.realize_term_substructure | Mathlib.ModelTheory.ElementaryMaps | ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : L.Structure M] {α : Type u_5} {S : L.Substructure M} (v : α → ↥S)
(t : L.Term α), FirstOrder.Language.Term.realize (Subtype.val ∘ v) t = ↑(FirstOrder.Language.Term.realize v t) | null | true |
_private.Mathlib.Data.Sum.Interval.0.Finset.inl_mem_sumLexLift._simp_1_1 | Mathlib.Data.Sum.Interval | ∀ {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6}
{f₁ : α₁ → β₁ → Finset γ₁} {f₂ : α₂ → β₂ → Finset γ₂} {g₁ : α₁ → β₂ → Finset γ₁} {g₂ : α₁ → β₂ → Finset γ₂}
{a : α₁ ⊕ α₂} {b : β₁ ⊕ β₂} {c : γ₁ ⊕ γ₂},
(c ∈ Finset.sumLexLift f₁ f₂ g₁ g₂ a b) =
((∃ a₁ b₁ c₁, a = S... | null | false |
_private.Mathlib.RingTheory.DiscreteValuationRing.Basic.0.IsDiscreteValuationRing.aux_pid_of_ufd_of_unique_irreducible._simp_1_4 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {α : Type u_1} [inst : Monoid α] {a b u : α}, IsUnit u → (a ∣ b * u) = (a ∣ b) | null | false |
_private.Init.Data.Int.Gcd.0.Int.gcd_le_right._proof_1_2 | Init.Data.Int.Gcd | ∀ {b : ℤ}, 0 < b → b = 0 → False | null | false |
MonoidWithZeroHom.inr_apply_unit | Mathlib.Algebra.GroupWithZero.ProdHom | ∀ {G₀ : Type u_1} {H₀ : Type u_2} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero H₀]
[inst_2 : DecidablePred fun x => x = 0] (x : H₀ˣ), (MonoidWithZeroHom.inr G₀ H₀) ↑x = ↑(1, x) | null | true |
_private.Mathlib.Order.Filter.SmallSets.0.Filter.eventually_smallSets_eventually._simp_1_2 | Mathlib.Order.Filter.SmallSets | ∀ {α : Type u} {f g : Filter α} {p : α → Prop}, (∀ᶠ (x : α) in f ⊓ g, p x) = ∃ s ∈ f, ∃ t ∈ g, ∀ x ∈ s ∩ t, p x | null | false |
_private.Mathlib.Algebra.Order.Field.Basic.0.sub_inv_antitoneOn_Icc_right._simp_1_1 | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u} {β : Type v} {s : Set α} [inst : Preorder α] [inst_1 : Preorder β] (f : α → β),
s.Subsingleton → AntitoneOn f s = True | null | false |
PUnit.instStrongNormalizedGCDMonoid._proof_5 | Mathlib.Algebra.GCDMonoid.PUnit | ∀ (x x_1 : PUnit.{u_1 + 1}), PUnit.unit * PUnit.unit * ↑1 = x * x_1 | null | false |
Submodule.inclusion._proof_1 | Mathlib.Algebra.Module.Submodule.LinearMap | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p p' : Submodule R M}, p ≤ p' → ∀ (x : ↥p), p.subtype x ∈ p' | null | false |
Bialgebra.TensorProduct.counitAlgHom_def | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) (B : Type u_4) [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Semiring A] [inst_3 : Semiring B] [inst_4 : Bialgebra S A] [inst_5 : Bialgebra R B] [inst_6 : Algebra R A]
[inst_7 : Algebra R S] [inst_8 : IsScalarTower R S A],
Bialgebra.counitAlgHom S (Tens... | null | true |
CategoryTheory.Under.mapCongr_inv_app | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X Y : T} (f g : X ⟶ Y) (h : f = g)
(X_1 : CategoryTheory.Under Y), (CategoryTheory.Under.mapCongr f g h).inv.app X_1 = CategoryTheory.eqToHom ⋯ | null | true |
_private.Lean.Widget.Diff.0.Lean.Widget.instEmptyCollectionExprDiff | Lean.Widget.Diff | EmptyCollection Lean.Widget.ExprDiff✝ | null | true |
CategoryTheory.Limits.biprod.opIso_hom_fst | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(P Q : C) [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct P Q],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.opIso P Q).hom CategoryTheory.Limits.biprod.fst =
CategoryTheory.Li... | null | true |
_private.Mathlib.Data.List.Sublists.0.List.revzip_sublists'._simp_1_7 | Mathlib.Data.List.Sublists | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∃ a, p a ∧ q a ∧ a = a') = (p a' ∧ q a') | null | false |
CharP.congr | Mathlib.Algebra.CharP.Defs | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (p : ℕ) [CharP R p] {q : ℕ}, p = q → CharP R q | null | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofLeGe.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{c₁ c₂ c₁' c₂' : Lean.Meta.Grind.Arith.Cutsat.LeCnstr} →
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofLeGe c₁ c₂ = Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofLeGe c₁' c₂' →
(c₁ = c₁' → c₂ = c₂' → P) → P | null | false |
Set.disjoint_univ | Mathlib.Data.Set.Disjoint | ∀ {α : Type u} {s : Set α}, Disjoint s Set.univ ↔ s = ∅ | null | true |
CategoryTheory.Iso.symm_self_id | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y), α.symm ≪≫ α = CategoryTheory.Iso.refl Y | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.