name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.MonObj.instTensorUnit._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
(CategoryTheory.CategoryStruct.id (CategoryTheory.Monoid... | false |
Finset.strongDownwardInduction.eq_1 | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {p : Finset α → Sort u_4} {n : ℕ}
(H : (t₁ : Finset α) → ({t₂ : Finset α} → t₂.card ≤ n → t₁ ⊂ t₂ → p t₂) → t₁.card ≤ n → p t₁) (x : Finset α),
Finset.strongDownwardInduction H x =
H x fun {t} ht h =>
have this := ⋯;
have this := ⋯;
Finset.strongDownwardInduction H t ht | true |
MeasureTheory.AEStronglyMeasurable.const_mul | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} [inst_1 : Mul β] [ContinuousMul β],
MeasureTheory.AEStronglyMeasurable f μ → ∀ (c : β), MeasureTheory.AEStronglyMeasurable (fun x => c * f x) μ | true |
Manifold.LiftSourceTargetPropertyAt.congr_iff_of_eventuallyEq | Mathlib.Geometry.Manifold.LocalSourceTargetProperty | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_4} {H : Type u_6} {G : Type u_8} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : TopologicalSpace H] [inst_6 : TopologicalSpace G] {I : ModelWithCorners ... | true |
_private.Mathlib.GroupTheory.QuotientGroup.Defs.0.QuotientAddGroup.ker_le_range_iff.match_1_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {H : Type u_1} {I : Type u_2} [inst : AddGroup H] [inst_1 : AddZeroClass I] (g : H →+ I) (motive : ↥g.ker → Prop)
(x : ↥g.ker), (∀ (val : H) (hx : val ∈ g.ker), motive ⟨val, hx⟩) → motive x | false |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.single_mem_cycles₁_iff._simp_1_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u, u, u} k G} (x : G →₀ ↑A),
(x ∈ groupHomology.cycles₁ A) = ((x.sum fun g a => (A.ρ g⁻¹) a) = x.sum fun x a => a) | false |
Polynomial.natDegree_C_mul_X_pow_le | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R] (a : R) (n : ℕ), (Polynomial.C a * Polynomial.X ^ n).natDegree ≤ n | true |
ContinuousCohomology.MultiInd.functor._unsafe_rec | Mathlib.Algebra.Category.ContinuousCohomology.Basic | (R : Type u_1) →
(G : Type u_2) →
[inst : CommRing R] →
[inst_1 : Group G] →
[inst_2 : TopologicalSpace R] →
[inst_3 : TopologicalSpace G] →
[IsTopologicalGroup G] → ℕ → CategoryTheory.Functor (Action (TopModuleCat R) G) (Action (TopModuleCat R) G) | false |
IsLeftCancelSMul.recOn | Mathlib.Algebra.Group.Action.Defs | {G : Type u_9} →
{P : Type u_10} →
[inst : SMul G P] →
{motive : IsLeftCancelSMul G P → Sort u} →
(t : IsLeftCancelSMul G P) → ((left_cancel' : ∀ (a : G) (b c : P), a • b = a • c → b = c) → motive ⋯) → motive t | false |
Lean.Expr.abstract | Lean.Expr | Lean.Expr → Array Lean.Expr → Lean.Expr | true |
Lean.Elab.ComputeKind.meta | Lean.Elab.DeclModifiers | Lean.Elab.ComputeKind | true |
Equiv.one_def | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_3} (e : α ≃ β) [inst : One β], 1 = e.symm 1 | true |
IsCoprime.isUnit_of_associated | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x y : R}, IsCoprime x y → Associated x y → IsUnit x ∧ IsUnit y | true |
WriterT.runThe | Mathlib.Control.Monad.Writer | {M : Type u → Type v} → {α : Type u} → (ω : Type u) → WriterT ω M α → M (α × ω) | true |
String.Legacy.Iterator.pos | Init.Data.String.Iterator | String.Legacy.Iterator → String.Pos.Raw | true |
Filter.Germ.sliceLeft._proof_1 | Mathlib.Topology.Germ | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {p : X × Y},
ContinuousAt (fun x => (x, p.2)) p.1 | false |
Std.TreeSet.Raw.get_minD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {fallback : α} {hc : t.minD fallback ∈ t}, t.get (t.minD fallback) hc = t.minD fallback | true |
Module.FaithfullyFlat.mk | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ {R : Type u} {M : Type v} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[toFlat : Module.Flat R M], (∀ ⦃m : Ideal R⦄, m.IsMaximal → m • ⊤ ≠ ⊤) → Module.FaithfullyFlat R M | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastRotateRight._proof_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (target : aig.ShiftTarget w),
∀ idx < w, ¬idx < w - target.distance % w → ¬idx - (w - target.distance % w) < w → False | false |
Subring.coe_neg | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] (s : Subring R) (x : ↥s), ↑(-x) = -↑x | true |
String.Slice.Pattern.Model.SlicesFrom.mk.congr_simp | Init.Data.String.Lemmas.Pattern.Split | ∀ {s : String.Slice} {startPos : s.Pos} (l l_1 : List s.Subslice) (e_l : l = l_1)
(any_head? : Option.any (fun x => decide (x.startInclusive = startPos)) l.head? = true),
{ l := l, any_head? := any_head? } = { l := l_1, any_head? := ⋯ } | true |
nhdsWithinLE_sup_nhdsWithinGE | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] {s : Set α} (a : α),
nhdsWithin a (s ∩ Set.Iic a) ⊔ nhdsWithin a (s ∩ Set.Ici a) = nhdsWithin a s | true |
NormedAddGroupHom.toAddCommGroup._proof_3 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_1} {V₂ : Type u_2} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(x : NormedAddGroupHom V₁ V₂), (-x).toFun = (-x).toFun | false |
Filter.mem_seq_iff | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter (α → β)} {g : Filter α} {s : Set β},
s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, u.seq t ⊆ s | true |
_private.Lean.Meta.SameCtorUtils.0.Lean.Meta.withSharedCtorIndices.go | Lean.Meta.SameCtorUtils | {α : Type} →
Lean.Expr →
(Array Lean.Expr → Array Lean.Expr → Array Lean.Expr → Array Lean.Expr → Lean.MetaM α) →
Array Lean.Expr → Array Lean.Expr → Array Lean.Expr → List Bool → List Lean.Expr → Array Lean.Expr → Lean.MetaM α | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.applyReplacementFun.visitLambda.match_1 | Mathlib.Tactic.Translate.Core | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((n : Lean.Name) → (d b : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.lam n d b bi)) →
((x : Lean.Expr) → motive x) → motive e | false |
Lean.Parser.Term.dynamicQuot._regBuiltin.Lean.Parser.Term.dynamicQuot.formatter_7 | Lean.Parser.Term | IO Unit | false |
Sublattice.comap._proof_2 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : Lattice β] (f : LatticeHom α β) (L : Sublattice β),
InfClosed (⇑f ⁻¹' ↑L) | false |
Lean.Elab.Tactic.Grind.State.mk._flat_ctor | Lean.Elab.Tactic.Grind.Basic | Lean.Meta.Sym.State → Lean.Meta.Grind.State → List Lean.Meta.Grind.Goal → Lean.Elab.Tactic.Grind.State | false |
Algebra.kerTensorProductMapIdToAlgHomEquiv_symm_apply | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_3)
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] {A : Type u_4}
[inst_7 : CommRing A] [inst_8 : Algebra R A] [inst_9 : Module.Flat R T] (h₁ : Function.Sur... | true |
Submodule.orthogonalDecomposition.eq_1 | Mathlib.Analysis.InnerProductSpace.ProdL2 | ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection],
K.orthogonalDecomposition =
{ toLinearEquiv := (K.prodEquivOfIsCompl Kᗮ ⋯).symm.trans (WithLp.linearEquiv 2 𝕜 (↥K × ↥Kᗮ)).symm, norm_m... | true |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_7 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a b : Array α},
j ≤ a.size →
-1 * ↑i + ↑a.size ≤ 0 →
¬-1 * ↑j + ↑a.size ≤ 0 →
¬↑i + -1 * ↑(min j (a ++ b).size) ≤ 0 →
∀ (w : ℕ), w + 1 ≤ ((a ++ b).extract i j).size → w < (a.extract i j).size | false |
upperCentralSeriesAux.match_1.congr_eq_1 | Mathlib.GroupTheory.Nilpotent | ∀ (motive : ℕ → Sort u_1) (x : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
x = 0 →
(match x with
| 0 => h_1 ()
| n.succ => h_2 n) ≍
h_1 () | true |
List.Palindrome.map | Mathlib.Data.List.Palindrome | ∀ {α : Type u_1} {β : Type u_2} {l : List α} (f : α → β), l.Palindrome → (List.map f l).Palindrome | true |
Set.infs_self._simp_1 | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeInf α] {s : Set α}, (s ⊼ s = s) = InfClosed s | false |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.SizeState.mk.injEq | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec | ∀ (relevantTerms : Std.HashSet Lean.Expr) (relevantHyps : Std.HashSet Lean.FVarId)
(relevantTerms_1 : Std.HashSet Lean.Expr) (relevantHyps_1 : Std.HashSet Lean.FVarId),
({ relevantTerms := relevantTerms, relevantHyps := relevantHyps } =
{ relevantTerms := relevantTerms_1, relevantHyps := relevantHyps_1 }) =
... | true |
CategoryTheory.Functor.leftOpRightOpEquiv_functor_obj_map | Mathlib.CategoryTheory.Opposites | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : (CategoryTheory.Functor Cᵒᵖ D)ᵒᵖ) {X Y : C} (f : X ⟶ Y),
((CategoryTheory.Functor.leftOpRightOpEquiv C D).functor.obj F).map f = ((Opposite.unop F).map f.op).op | true |
Lean.Compiler.LCNF.LitValue.str.injEq | Lean.Compiler.LCNF.Basic | ∀ (val val_1 : String), (Lean.Compiler.LCNF.LitValue.str val = Lean.Compiler.LCNF.LitValue.str val_1) = (val = val_1) | true |
LieAlgebra.Basis | Mathlib.Algebra.Lie.Basis | (ι : Type u_1) →
(R : Type u_2) →
(L : Type u_3) → [Finite ι] → [inst : CommRing R] → [inst_1 : LieRing L] → [LieAlgebra R L] → Type (max u_1 u_3) | true |
Matrix.traceLinearMap._proof_1 | Mathlib.LinearAlgebra.Matrix.Trace | ∀ (n : Type u_1) (α : Type u_3) (R : Type u_2) [inst : Fintype n] [inst_1 : AddCommMonoid R] [inst_2 : Semiring α]
[inst_3 : Module α R] (r : α) (A : Matrix n n R), (r • A).trace = r • A.trace | false |
Lean.Lsp.LeanFileProgressKind._sizeOf_1 | Lean.Data.Lsp.Extra | Lean.Lsp.LeanFileProgressKind → ℕ | false |
CategoryTheory.pathComposition_map | Mathlib.CategoryTheory.PathCategory.Basic | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : CategoryTheory.Paths C} (f : X ⟶ Y),
(CategoryTheory.pathComposition C).map f = CategoryTheory.composePath f | true |
_private.Lean.Compiler.IR.Sorry.0.Lean.IR.updateSorryDep.match_1 | Lean.Compiler.IR.Sorry | (motive : Unit × Lean.IR.Sorry.State → Sort u_1) →
(__discr : Unit × Lean.IR.Sorry.State) → ((fst : Unit) → (s : Lean.IR.Sorry.State) → motive (fst, s)) → motive __discr | false |
Module.Basis.ofIsCoprimeDifferentIdeal._proof_5 | Mathlib.RingTheory.DedekindDomain.LinearDisjoint | ∀ (A : Type u_1) (B : Type u_2) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B], IsScalarTower A B B | false |
Submonoid.units_surjective | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M], Function.Surjective Submonoid.units | true |
Lean.ModuleDoc._sizeOf_inst | Lean.DocString.Extension | SizeOf Lean.ModuleDoc | false |
CategoryTheory.ProjectivePresentation.mk._flat_ctor | Mathlib.CategoryTheory.Preadditive.Projective.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
(p : C) →
[projective : CategoryTheory.Projective p] →
(f : p ⟶ X) → [epi : CategoryTheory.Epi f] → CategoryTheory.ProjectivePresentation X | false |
SimpleGraph.edist_eq_top_of_not_reachable | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V}, ¬G.Reachable u v → G.edist u v = ⊤ | true |
Equidecomp.mk.injEq | Mathlib.Algebra.Group.Action.Equidecomp | ∀ {X : Type u_1} {G : Type u_2} [inst : SMul G X] (toPartialEquiv : PartialEquiv X X)
(isDecompOn' : ∃ S, Equidecomp.IsDecompOn (↑toPartialEquiv) toPartialEquiv.source S)
(toPartialEquiv_1 : PartialEquiv X X)
(isDecompOn'_1 : ∃ S, Equidecomp.IsDecompOn (↑toPartialEquiv_1) toPartialEquiv_1.source S),
({ toPartia... | true |
Lean.Widget.TaggedText.below_2 | Lean.Widget.TaggedText | {α : Type u} →
{motive_1 : Lean.Widget.TaggedText α → Sort u_1} →
{motive_2 : Array (Lean.Widget.TaggedText α) → Sort u_1} →
{motive_3 : List (Lean.Widget.TaggedText α) → Sort u_1} → List (Lean.Widget.TaggedText α) → Sort (max (u + 1) u_1) | false |
CompHausLike.is_hausdorff | Mathlib.Topology.Category.CompHausLike.Basic | ∀ {P : TopCat → Prop} (self : CompHausLike P), T2Space ↑self.toTop | true |
t2Space_quotient_addAction_of_properVAdd | Mathlib.Topology.Algebra.ProperAction.Basic | ∀ {G : Type u_1} {X : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G X] [inst_2 : TopologicalSpace G]
[inst_3 : TopologicalSpace X] [ProperVAdd G X], T2Space (Quotient (AddAction.orbitRel G X)) | true |
MeasureTheory.Measure.instInnerRegularOfPseudoMetrizableSpaceOfSigmaCompactSpaceOfBorelSpaceOfSigmaFinite | Mathlib.MeasureTheory.Measure.Regular | ∀ {X : Type u_3} [inst : TopologicalSpace X] [TopologicalSpace.PseudoMetrizableSpace X] [SigmaCompactSpace X]
[inst_3 : MeasurableSpace X] [BorelSpace X] (μ : MeasureTheory.Measure X) [MeasureTheory.SigmaFinite μ],
μ.InnerRegular | true |
NormedCommRing.induced._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_2} (R : Type u_1) (S : Type u_3) [inst : FunLike F R S] [inst_1 : CommRing R] [inst_2 : NormedRing S]
[inst_3 : NonUnitalRingHomClass F R S] (f : F) (hf : Function.Injective ⇑f) {x y : R}, dist x y = 0 → x = y | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.map'._proof_5 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (i j : ℕ),
autoParam (i ≤ j) CategoryTheory.ComposableArrows.map'._auto_1 →
autoParam (j ≤ n) CategoryTheory.ComposableArrows.map'._auto_3 → i < n + 1 | false |
_private.Mathlib.RingTheory.Ideal.Maps.0.RingHom.ker_evalRingHom._simp_1_1 | Mathlib.RingTheory.Ideal.Maps | ∀ {α : Type u} [inst : Semiring α] {s : Set α} {I : Ideal α}, (Ideal.span s ≤ I) = (s ⊆ ↑I) | false |
Subsemigroup.top_prod_top | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N], ⊤.prod ⊤ = ⊤ | true |
_private.Mathlib.Probability.Distributions.Gaussian.IsGaussianProcess.Basic.0.ProbabilityTheory.IsGaussianProcess.of_isGaussianProcess._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.IsGaussianProcess.Basic | ∀ {ι : Type u_1} {M : ι → Type u_5} [inst : (i : ι) → Add (M i)] (f g : (i : ι) → M i), (fun i => f i + g i) = f + g | false |
AlgebraicGeometry.instIsAffineHomDescScheme | Mathlib.AlgebraicGeometry.Morphisms.Affine | ∀ {U V X : AlgebraicGeometry.Scheme} (f : U ⟶ X) (g : V ⟶ X) [AlgebraicGeometry.IsAffineHom f]
[AlgebraicGeometry.IsAffineHom g], AlgebraicGeometry.IsAffineHom (CategoryTheory.Limits.coprod.desc f g) | true |
CategoryTheory.Limits.whiskeringLimYonedaIsoCones_inv_app_app | Mathlib.CategoryTheory.Limits.Types.Yoneda | ∀ (J : Type v) [inst : CategoryTheory.SmallCategory J] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
(X : CategoryTheory.Functor J C) (X_1 : Cᵒᵖ) (a : X.cones.obj X_1),
((CategoryTheory.Limits.whiskeringLimYonedaIsoCones J C).inv.app X).app X_1 a =
(CategoryTheory.Limits.Types.limitEquivSections (X.c... | true |
Lean.Doc.Inline.linebreak.inj | Lean.DocString.Types | ∀ {i : Type u} {string string_1 : String},
Lean.Doc.Inline.linebreak string = Lean.Doc.Inline.linebreak string_1 → string = string_1 | true |
Set.Nonempty.compl_ssubset_univ | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s : Set α}, s.Nonempty → sᶜ ⊂ Set.univ | true |
MonoidWithZeroHom.comp_id | Mathlib.Algebra.GroupWithZero.Hom | ∀ {α : Type u_2} {β : Type u_3} [inst : MulZeroOneClass α] [inst_1 : MulZeroOneClass β] (f : α →*₀ β),
f.comp (MonoidWithZeroHom.id α) = f | true |
Lean.Parser.Tactic.Grind.instantiate | Init.Grind.Interactive | Lean.ParserDescr | true |
Lean.IR.EmitLLVM.Context.noConfusionType | Lean.Compiler.IR.EmitLLVM | Sort u →
{llvmctx : LLVM.Context} →
Lean.IR.EmitLLVM.Context llvmctx → {llvmctx' : LLVM.Context} → Lean.IR.EmitLLVM.Context llvmctx' → Sort u | false |
_private.Init.Data.Format.Basic.0.Std.Format.prefixJoin.match_1 | Init.Data.Format.Basic | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((a : α) → (as : List α) → motive (a :: as)) → motive x | false |
SSet.RelativeMorphism.Homotopy.h₁_assoc | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y : SSet} {A : X.Subcomplex} {B : Y.Subcomplex} {φ : A.toSSet ⟶ B.toSSet} {f g : SSet.RelativeMorphism A B φ}
(self : f.Homotopy g) {Z : SSet} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp SSet.ι₁ (CategoryTheory.CategoryStruct.comp self.h h) =
CategoryTheory.CategoryStruct.comp g.map h | true |
MvPolynomial.leadingCoeff_toLex | Mathlib.Algebra.MvPolynomial.Variables | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} [inst_1 : LinearOrder σ],
AddMonoidAlgebra.leadingCoeff (⇑toLex) p = MvPolynomial.coeff (ofLex (AddMonoidAlgebra.supDegree (⇑toLex) p)) p | true |
CommMonoid.toMonoid_injective | Mathlib.Algebra.Group.Ext | ∀ {M : Type u}, Function.Injective (@CommMonoid.toMonoid M) | true |
HomotopicalAlgebra.instWeakEquivalenceLeftDiscretePUnitOfOver | Mathlib.AlgebraicTopology.ModelCategory.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (S : C)
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] {X Y : CategoryTheory.Over S} (f : X ⟶ Y)
[HomotopicalAlgebra.WeakEquivalence f], HomotopicalAlgebra.WeakEquivalence f.left | true |
OrderDual.instSMulCommClass_2 | Mathlib.Algebra.Order.Group.Action.Synonym | ∀ {M : Type u_1} {N : Type u_2} {α : Type u_3} [inst : SMul M α] [inst_1 : SMul N α] [SMulCommClass M N α],
SMulCommClass M N αᵒᵈ | true |
gaugeSeminormFamily._proof_1 | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : Module 𝕜 E] (s : AbsConvexOpenSets 𝕜 E), Balanced 𝕜 ↑s | false |
Quaternion.instRing._aux_20 | Mathlib.Algebra.Quaternion | {R : Type u_1} → [inst : CommRing R] → Quaternion R | false |
ProfiniteGrp.mk | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | (toProfinite : Profinite) →
[group : Group ↑toProfinite.toTop] → [topologicalGroup : IsTopologicalGroup ↑toProfinite.toTop] → ProfiniteGrp.{u} | true |
Std.Net.instInhabitedAddressFamily | Std.Net.Addr | Inhabited Std.Net.AddressFamily | true |
_private.Mathlib.LinearAlgebra.Basis.Defs.0.Module.Basis.coe_ofEquivFun._simp_1_2 | Mathlib.LinearAlgebra.Basis.Defs | ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] [inst_1 : DecidableEq α] (a : α) (b : M), Pi.single a b = ⇑fun₀ | a => b | false |
definition._@.Mathlib.Analysis.InnerProductSpace.PiL2.2921777918._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.PiL2 | (𝕜 : Type u_3) →
[inst : RCLike 𝕜] →
(E : Type u_4) →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] → [FiniteDimensional 𝕜 E] → OrthonormalBasis (Fin (Module.finrank 𝕜 E)) 𝕜 E | false |
_private.Mathlib.Algebra.BigOperators.Group.List.Basic.0.List.sum_neg_reverse.match_1_1 | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_1} (motive : List G → Prop) (x : List G),
(∀ (a : Unit), motive []) → (∀ (x : G) (xs : List G), motive (x :: xs)) → motive x | false |
LinearMap.IsSymmetric.conj_eigenvalue_eq_self | Mathlib.Analysis.InnerProductSpace.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E}, T.IsSymmetric → ∀ {μ : 𝕜}, Module.End.HasEigenvalue T μ → (starRingEnd 𝕜) μ = μ | true |
FirstOrder.Language.BoundedFormula.IsAtomic.rec | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u'} {n : ℕ} {motive : (a : L.BoundedFormula α n) → a.IsAtomic → Prop},
(∀ (t₁ t₂ : L.Term (α ⊕ Fin n)), motive (t₁.bdEqual t₂) ⋯) →
(∀ {l : ℕ} (R : L.Relations l) (ts : Fin l → L.Term (α ⊕ Fin n)), motive (R.boundedFormula ts) ⋯) →
∀ {a : L.BoundedFormula α n} (t : a.Is... | false |
CategoryTheory.Comonad.ComonadicityInternal.comparisonAdjunction_counit_f | Mathlib.CategoryTheory.Monad.Comonadicity | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} {adj : F ⊣ G}
[inst_2 : ∀ (A : adj.toComonad.Coalgebra), CategoryTheory.Limits.HasEqualizer (G.map A.a) (adj.unit.app (G.obj A.A))... | true |
_private.Mathlib.Topology.Bases.0.TopologicalSpace.exists_countable_of_generateFrom._proof_1_3 | Mathlib.Topology.Bases | ∀ {α : Type u_1} (s' : Set (Set α)) (f : Set α → Set (Set α)) ⦃u : Set α⦄, u ∈ s' → ∀ i ∈ f u, ∃ i_1 ∈ s', i ∈ f i_1 | false |
Rep.mkIso._proof_2 | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u_2} {G : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] {X Y : Type u_1} [inst_2 : AddCommGroup X]
[inst_3 : AddCommGroup Y] [inst_4 : Module k X] [inst_5 : Module k Y] {ρ : Representation k G X}
{σ : Representation k G Y} (e : ρ.Equiv σ),
CategoryTheory.CategoryStruct.comp (Rep.ofHom ↑e) (Rep.ofH... | false |
_private.Mathlib.Data.Finset.Lattice.Prod.0.Finset.sup_prodMap._simp_1_2 | Mathlib.Data.Finset.Lattice.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | false |
Condensed.isoFinYoneda | Mathlib.Condensed.Discrete.Colimit | (F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u + 1))) →
[CategoryTheory.Limits.PreservesFiniteProducts F] → FintypeCat.toProfinite.op.comp F ≅ Condensed.finYoneda F | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.independent_genEigenspace._simp_1_2 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {α : Type u_1} {ι : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] {s : Finset ι} {f : ι → α}
[inst_2 : DecidableEq ι], s.SupIndep f = ∀ i ∈ s, Disjoint (f i) ((s.erase i).sup f) | false |
MonoidHom.comap_bot' | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F), Submonoid.comap f ⊥ = MonoidHom.mker f | true |
CategoryTheory.FreeBicategory.bicategory._proof_17 | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u_1} [inst : Quiver B] (x x_1 x_2 x_3 x_4 : CategoryTheory.FreeBicategory B) (f : x ⟶ x_1) (g : x_1 ⟶ x_2)
(h : x_2 ⟶ x_3) (i : x_3 ⟶ x_4),
Quot.mk CategoryTheory.FreeBicategory.Rel
((CategoryTheory.FreeBicategory.Hom₂.whisker_right i (CategoryTheory.FreeBicategory.Hom₂.associator f g h)).vcomp
... | false |
CategoryTheory.isoMk._proof_3 | Mathlib.CategoryTheory.Widesubcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {P : CategoryTheory.MorphismProperty C}
[inst_1 : P.IsMultiplicative] {X Y : CategoryTheory.WideSubcategory P} (e : X.obj ≅ Y.obj) (h₁ : P e.hom)
(h₂ : P e.inv),
CategoryTheory.CategoryStruct.comp { hom := e.hom, property := h₁ } { hom := e.inv, prope... | false |
Int.instSuccOrder._proof_2 | Mathlib.Data.Int.SuccPred | ∀ (a : ℤ), a ≤ SuccOrder.succ a | false |
Equiv.divisionRing._proof_9 | Mathlib.Algebra.Field.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : DivisionRing β] (n : ℕ) (x : α), e (e.symm (n • e x)) = n • e x | false |
CategoryTheory.Abelian.SpectralObject.sc₃_f | Mathlib.Algebra.Homology.SpectralObject.Basic | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
[inst_1 : CategoryTheory.Category.{u_4, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n₀ n... | true |
CategoryTheory.Functor.HasPointwiseLeftDerivedFunctorAt.recOn | Mathlib.CategoryTheory.Functor.Derived.PointwiseLeftDerived | {C : Type u₁} →
{H : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₃, u₃} H] →
{F : CategoryTheory.Functor C H} →
{W : CategoryTheory.MorphismProperty C} →
{X : C} →
{motive : F.HasPointwiseLeftDerivedFunctorAt W X → ... | false |
Subalgebra.instCommRingSubtypeMemCenter._proof_16 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Ring A] [inst_2 : Algebra R A]
(a b : ↥(Subalgebra.center R A)), a * b = b * a | false |
HeytingHom.comp | Mathlib.Order.Heyting.Hom | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : HeytingAlgebra α] →
[inst_1 : HeytingAlgebra β] → [inst_2 : HeytingAlgebra γ] → HeytingHom β γ → HeytingHom α β → HeytingHom α γ | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.card_mul_finset_lt_two._simp_1_7 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | false |
_private.Mathlib.Algebra.MvPolynomial.Variables.0.MvPolynomial.vars_add_subset._simp_1_2 | Mathlib.Algebra.MvPolynomial.Variables | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, (a ∈ s.toFinset) = (a ∈ s) | false |
MvPolynomial.support_esymm | Mathlib.RingTheory.MvPolynomial.Symmetric.Defs | ∀ (σ : Type u_5) (R : Type u_6) [inst : CommSemiring R] [inst_1 : Fintype σ] [inst_2 : DecidableEq σ] [Nontrivial R]
(n : ℕ),
(MvPolynomial.esymm σ R n).support =
Finset.image (fun t => ∑ i ∈ t, fun₀ | i => 1) (Finset.powersetCard n Finset.univ) | true |
_private.Std.Sync.Broadcast.0.Std.Slot.casesOn | Std.Sync.Broadcast | {α : Type} →
{motive : Std.Slot✝ α → Sort u} →
(t : Std.Slot✝¹ α) →
((value : Option α) → (pos remaining : ℕ) → motive { value := value, pos := pos, remaining := remaining }) →
motive t | false |
_private.Lean.Meta.Tactic.Cbv.Util.0.Lean.Meta.Tactic.Cbv.isProp._sparseCasesOn_1 | Lean.Meta.Tactic.Cbv.Util | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.