name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
HomologicalComplex.instHasFilteredColimitsOfSize | Mathlib.Algebra.Homology.GrothendieckAbelian | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {ι : Type t} (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w', v, u} C],
CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w', max t v, max (max t u) v} (HomologicalComplex C c) | true |
CategoryTheory.constantCommuteCompose_hom_app_val | Mathlib.CategoryTheory.Sites.ConstantSheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
{D : Type u_2} [inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.HasWeakSheafify J D]
{B : Type u_3} [inst_3 : CategoryTheory.Category.{v_3, u_3} B] (U : CategoryTheory.Functor D B)
[i... | true |
Lean.Lsp.DependencyBuildMode.never.sizeOf_spec | Lean.Data.Lsp.Extra | sizeOf Lean.Lsp.DependencyBuildMode.never = 1 | true |
LinearMap.tensorProduct._proof_5 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (A : Type u_2) (M : Type u_4) (N : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : AddCommMonoid N]
[inst_6 : Module R N], IsScalarTower R A (TensorProduct R A M →ₗ[A] TensorProduct R A N) | false |
Std.Broadcast.noConfusion | Std.Sync.Broadcast | {P : Sort u} →
{α : Type} →
{t : Std.Broadcast α} →
{α' : Type} → {t' : Std.Broadcast α'} → α = α' → t ≍ t' → Std.Broadcast.noConfusionType P t t' | false |
UInt64.sub_eq_add_neg | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a - b = a + -b | true |
Mathlib.Meta.FunProp.MorApplication.ctorIdx | Mathlib.Tactic.FunProp.FunctionData | Mathlib.Meta.FunProp.MorApplication → ℕ | false |
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.not_summable_residueClass_prime_div._simp_1_4 | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [Nontrivial α] {n : ℕ}
[inst_4 : n.AtLeastTwo], (0 < OfNat.ofNat n) = True | false |
Submodule._aux_Mathlib_Analysis_InnerProductSpace_Orthogonal___unexpand_Submodule_IsOrtho_1 | Mathlib.Analysis.InnerProductSpace.Orthogonal | Lean.PrettyPrinter.Unexpander | false |
_private.Lean.Replay.0.Lean.Environment.Replay.checkPostponedConstructors._sparseCasesOn_1 | Lean.Replay | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (Lean.ConstantInfo.ctorInfo val)) →
(Nat.hasNotBit 64 t.ctorIdx → motive t) → motive t | false |
Lean.Meta.Sym.State.inferType._default | Lean.Meta.Sym.SymM | Lean.PersistentHashMap Lean.Meta.Sym.ExprPtr Lean.Expr | false |
Matroid.cRk_closure_congr | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u} {M : Matroid α} {X Y : Set α} [M.InvariantCardinalRank], M.closure X = M.closure Y → M.cRk X = M.cRk Y | true |
Nat.dfold_add._auto_5 | Init.Data.Nat.Fold | Lean.Syntax | false |
Lean.Json.json_ | Lean.Data.Json.Elab | Lean.ParserDescr | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.State.mk.injEq | Lean.Compiler.LCNF.ExplicitRC | ∀ (liveVars liveVars_1 : Lean.Compiler.LCNF.LiveVars✝),
({ liveVars := liveVars } = { liveVars := liveVars_1 }) = (liveVars = liveVars_1) | true |
Fintype.toOrderBot._proof_1 | Mathlib.Data.Fintype.Order | ∀ (α : Type u_1) [inst : Fintype α] (a : α), ∃ x, x ∈ Finset.univ | false |
mem_const_vsub_affineSegment | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x y z : P} (p : P),
p -ᵥ z ∈ affineSegment R (p -ᵥ x) (p -ᵥ y) ↔ z ∈ affineSegment R x y | true |
IO.CancelToken.noConfusion | Init.System.IO | {P : Sort u} → {t t' : IO.CancelToken} → t = t' → IO.CancelToken.noConfusionType P t t' | false |
TopologicalSpace.OpenNhdsOf.instDistribLattice._proof_1 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {x_1 y : TopologicalSpace.OpenNhdsOf x},
x_1.toOpens ≤ y.toOpens ↔ x_1.toOpens ≤ y.toOpens | false |
QuadraticMap.linMulLin.congr_simp | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {A : Type u_7} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : Module R A] [inst_5 : SMulCommClass R A A]
[inst_6 : IsScalarTower R A A] (f f_1 : M →ₗ[R] A),
f = f_1 → ∀ (g g_1 : M →ₗ[R] A), g = g_1 → Quadrat... | true |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Impl.pruneLE.eq_1 | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (lowerBound : α),
Std.DTreeMap.Internal.Impl.pruneLE✝ Std.DTreeMap.Internal.Impl.leaf lowerBound = Std.DTreeMap.Internal.Impl.leaf | true |
Std.DTreeMap.Const.contains_alter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k k' : α}
{f : Option β → Option β},
(Std.DTreeMap.Const.alter t k f).contains k' =
if cmp k k' = Ordering.eq then (f (Std.DTreeMap.Const.get? t k)).isSome else t.contains k' | true |
SetRel.IsCover.anti | Mathlib.Data.Rel.Cover | ∀ {X : Type u_1} {U : SetRel X X} {s t N : Set X}, s ⊆ t → U.IsCover t N → U.IsCover s N | true |
_private.Mathlib.RingTheory.Etale.Field.0.Algebra.FormallyEtale.of_isSeparable._simp_1_1 | Mathlib.RingTheory.Etale.Field | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | false |
Filter.Eventually.mp | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x) → (∀ᶠ (x : α) in f, p x → q x) → ∀ᶠ (x : α) in f, q x | true |
PiTensorProduct.definition._proof_2._@.Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm.2741663271._hygCtx._hyg.2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] (G : Type (max u_3 u_1 u_2)) (x : SeminormedAddCommGroup G)
(x_1 : NormedSpace 𝕜 G), ContinuousConstSMul 𝕜 G | false |
_private.Mathlib.Analysis.Complex.AbelLimit.0.Complex.tendsto_tsum_powerSeries_nhdsWithin_stolzSet._simp_1_6 | Mathlib.Analysis.Complex.AbelLimit | ∀ {α : Type u_2} [inst : Norm α] [inst_1 : Mul α] [NormMulClass α] (a b : α), ‖a‖ * ‖b‖ = ‖a * b‖ | false |
real_inner_div_norm_mul_norm_eq_neg_one_iff | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x y : F),
inner ℝ x y / (‖x‖ * ‖y‖) = -1 ↔ x ≠ 0 ∧ ∃ r < 0, y = r • x | true |
PFunctor.M.dest_mk | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} (x : ↑F F.M), (PFunctor.M.mk x).dest = x | true |
Lean.SubExpr.Pos.pushNthBindingDomain | Lean.SubExpr | ℕ → Lean.SubExpr.Pos → Lean.SubExpr.Pos | true |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.getFalseProof? | Lean.Meta.Tactic.Grind.Split | Lean.MVarId → Lean.MetaM (Option Lean.Expr) | true |
Std.ExtTreeMap.maxKey_eq_iff_mem_and_forall | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {he : t ≠ ∅} {km : α}, t.maxKey he = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp k km).isLE = true | true |
AlgebraNorm.algebraNormClass | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : Type u_1} [inst : SeminormedCommRing R] {S : Type u_2} [inst_1 : Ring S] [inst_2 : Algebra R S],
AlgebraNormClass (AlgebraNorm R S) R S | true |
Lean.Compiler.LCNF.ToMonoM.State.mk.sizeOf_spec | Lean.Compiler.LCNF.ToMono | ∀ (typeParams : Lean.FVarIdHashSet), sizeOf { typeParams := typeParams } = 1 + sizeOf typeParams | true |
LieAlgebra.hasTrivialRadical_iff | Mathlib.Algebra.Lie.Semisimple.Defs | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieAlgebra.HasTrivialRadical R L ↔ LieAlgebra.radical R L = ⊥ | true |
IsSelfAdjoint.cfc_arg | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u : A), IsSelfAdjoint (cfc (Complex.ofReal ∘ Complex.arg) u) | true |
ContinuousMap.id._proof_1 | Mathlib.Topology.ContinuousMap.Basic | ∀ (α : Type u_1) [inst : TopologicalSpace α], Continuous id | false |
Fin.tail_vecCons | Mathlib.Data.Fin.VecNotation | ∀ {α : Type u} {n : ℕ} (x : α) (t : Fin n → α), Fin.tail (Matrix.vecCons x t) = t | true |
WittVector.IsocrystalHom.mk.inj | Mathlib.RingTheory.WittVector.Isocrystal | ∀ {p : ℕ} {inst : Fact (Nat.Prime p)} {k : Type u_1} {inst_1 : CommRing k} {inst_2 : CharP k p}
{inst_3 : PerfectRing k p} {V : Type u_2} {inst_4 : AddCommGroup V} {inst_5 : WittVector.Isocrystal p k V}
{V₂ : Type u_3} {inst_6 : AddCommGroup V₂} {inst_7 : WittVector.Isocrystal p k V₂}
{toLinearMap : V →ₗ[Fraction... | true |
DirectLimit.instGroupWithZero._proof_16 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : (i : ι) → GroupWithZero (G i)] [∀ (i j : ι) (h : i ≤ j), MonoidWithZeroHomClass (T h) (G i) (G j)] (n : ℕ)
(x ... | false |
Lean.Meta.LazyDiscrTree.MatchResult.push | Lean.Meta.LazyDiscrTree | {α : Type} → Lean.Meta.LazyDiscrTree.MatchResult α → ℕ → Array α → Lean.Meta.LazyDiscrTree.MatchResult α | true |
Std.DHashMap.Internal.Raw₀.getKey_filter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : (a : α) → β a → Bool} {k : α} (h : (↑m).WF)
{h' : (Std.DHashMap.Internal.Raw₀.filter f m).contains k = true},
(Std.DHashMap.Internal.Raw₀.filter f m).get... | true |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.rintroContinue.loop._unsafe_rec | Lean.Elab.Tactic.RCases | {α : Type} →
Lean.Syntax →
Lean.TSyntaxArray `rintroPat →
Option Lean.Term →
(Lean.MVarId → Lean.Meta.FVarSubst → Array Lean.FVarId → α → Lean.Elab.TermElabM α) →
ℕ → Lean.MVarId → Lean.Meta.FVarSubst → Array Lean.FVarId → α → Lean.Elab.TermElabM α | false |
_private.Mathlib.Combinatorics.SetFamily.Shadow.0.Finset.upShadow_compls._simp_1_2 | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α},
(t ∈ 𝒜.upShadow) = ∃ s ∈ 𝒜, ∃ a ∉ s, insert a s = t | false |
CentroidHom.toEndRingHom_apply | Mathlib.Algebra.Ring.CentroidHom | ∀ (α : Type u_5) [inst : NonUnitalNonAssocSemiring α] (f : CentroidHom α), (CentroidHom.toEndRingHom α) f = f.toEnd | true |
IntermediateField.eq_of_le_of_finrank_eq | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {F E : IntermediateField K L}
[FiniteDimensional K ↥E], F ≤ E → Module.finrank K ↥F = Module.finrank K ↥E → F = E | true |
Std.Internal.IO.Async.EAsync.ofTask | Std.Internal.Async.Basic | {ε α : Type} → Std.Internal.IO.Async.ETask ε α → Std.Internal.IO.Async.EAsync ε α | true |
HomotopicalAlgebra.instHasTwoOutOfThreePropertyFullSubcategoryWeakEquivalences | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
{P : CategoryTheory.ObjectProperty C} [(HomotopicalAlgebra.weakEquivalences C).HasTwoOutOfThreeProperty],
(HomotopicalAlgebra.weakEquivalences P.FullSubcategory).HasTwoOutOfThreeProperty | true |
Lean.Grind.ISize.natCast | Init.GrindInstances.Ring.SInt | NatCast ISize | true |
CategoryTheory.SingleFunctors.shiftIso_zero_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {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] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] (F : CategoryTheory.SingleFunctors C D A) (a : A) (X : C),
(F.shiftIso 0 a a ⋯).hom.app X = (CategoryTheory.shi... | true |
LieModule.maxTrivEquiv._proof_1 | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_1} {N : Type u_4} [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] [inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : LieRingModule L N]
[ins... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_eq_getKeyD._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
_private.Lean.Compiler.IR.Checker.0.Lean.IR.Checker.checkExpr.match_4 | Lean.Compiler.IR.Checker | (motive : Lean.IR.Expr → Sort u_1) →
(e : Lean.IR.Expr) →
((f : Lean.IR.FunId) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.pap f ys)) →
((x : Lean.IR.VarId) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.ap x ys)) →
((f : Lean.IR.FunId) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.fap ... | false |
Set.vsub_iUnion | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} {β : Type u_3} {ι : Sort u_5} [inst : VSub α β] (s : Set β) (t : ι → Set β),
s -ᵥ ⋃ i, t i = ⋃ i, s -ᵥ t i | true |
WithTop.forall_ne_top | Mathlib.Order.WithBot | ∀ {α : Type u_1} {p : WithTop α → Prop}, (∀ (x : WithTop α), x ≠ ⊤ → p x) ↔ ∀ (x : α), p ↑x | true |
CategoryTheory.Limits.coneOfConeCurry_pt | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] {C : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
(G : CategoryTheory.Functor (J × K) C) {D : CategoryTheory.Limits.DiagramOfCones (CategoryTheory.Functor.curry.obj G)}
(Q : (... | true |
CategoryTheory.MonoidalPreadditive.instAdditiveFunctorFlipCurriedTensor | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C],
(CategoryTheory.MonoidalCategory.curriedTensor C).flip.Additive | true |
ExistsContDiffBumpBase.y_eq_one_of_mem_closedBall | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] {D : ℝ} {x : E},
0 < D → x ∈ Metric.closedBall 0 (1 - D) → ExistsContDiffBumpBase.y D x = 1 | true |
ModuleCat.ExtendRestrictScalarsAdj.Counit.map._proof_3 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_3} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) {Y : ModuleCat S} (s : S)
(r : R) (y : ↑Y), s • r • y = f r • s • y | false |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_exists_annihilator._simp_1_2 | Mathlib.RingTheory.Support | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | false |
Left.self_le_neg | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : Preorder α] [AddLeftMono α] {a : α}, a ≤ 0 → a ≤ -a | true |
_private.Init.Data.Array.Find.0.Array.getElem_zero_flatten.proof._simp_1_2 | Init.Data.Array.Find | ∀ {l : List ℕ}, (0 < l.sum) = ∃ x ∈ l, 0 < x | false |
meromorphicAt_of_meromorphicOrderAt_ne_zero | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜}, meromorphicOrderAt f x ≠ 0 → MeromorphicAt f x | true |
TopologicalSpace.Compacts.mem_singleton | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] (x y : α), x ∈ {y} ↔ x = y | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.isOpen_B._simp_1_2 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {X : Type u} {α : Type u_1} [inst : TopologicalSpace X] {s : Set α} {f : α → Set X},
(∀ i ∈ s, IsOpen (f i)) → IsOpen (⋃ i ∈ s, f i) = True | false |
Nat.le_of_ble_eq_true | Init.Prelude | ∀ {n m : ℕ}, n.ble m = true → n ≤ m | true |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.veblenWith.match_1.eq_1 | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}) (motive : { x // x ∈ Set.Iio o } → Sort u_2) (x : Ordinal.{u_1}) (property : x ∈ Set.Iio o)
(h_1 : (x : Ordinal.{u_1}) → (property : x ∈ Set.Iio o) → motive ⟨x, property⟩),
(match ⟨x, property⟩ with
| ⟨x, property⟩ => h_1 x property) =
h_1 x property | true |
CategoryTheory.WithTerminal.equivComma_functor_map_left_app | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
{X Y : CategoryTheory.Functor (CategoryTheory.WithTerminal C) D} (η : X ⟶ Y) (X_1 : C),
(CategoryTheory.WithTerminal.equivComma.functor.map η).left.app X_1 = η.app (CategoryTheory.WithTerminal.inc... | true |
SimpleGraph.EdgeLabeling.compRight_get | Mathlib.Combinatorics.SimpleGraph.EdgeLabeling | ∀ {V : Type u_1} {G : SimpleGraph V} {K : Type u_3} {K' : Type u_4} {C : G.EdgeLabeling K} (f : K → K') (x y : V)
(h : G.Adj x y), (C.compRight f).get x y h = f (C.get x y h) | true |
BoolRing.instCategory._proof_2 | Mathlib.Algebra.Category.BoolRing | ∀ {X Y : BoolRing} (f : X.Hom Y), { hom' := { hom' := RingHom.id ↑Y }.hom'.comp f.hom' } = f | false |
CochainComplex.singleFunctors.eq_1 | Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C],
CochainComplex.singleFunctors C =
{ functor := fun n => HomologicalComplex.single C (ComplexShape.up ℤ) n,
shiftIso := fun n a a' ha' =>
CategoryTheory... | true |
TopologicalSpace.Clopens.exists_finset_eq_sup_prod | Mathlib.Topology.ClopenBox | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [CompactSpace Y]
[CompactSpace X] (W : TopologicalSpace.Clopens (X × Y)), ∃ I, W = I.sup fun i => i.1 ×ˢ i.2 | true |
Subalgebra.mulMap_comm | Mathlib.LinearAlgebra.TensorProduct.Subalgebra | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
(A B : Subalgebra R S), B.mulMap A = (A.mulMap B).comp ↑(Algebra.TensorProduct.comm R ↥B ↥A) | true |
instSliceableByteArrayNatByteSlice_3 | Std.Data.ByteSlice | Std.Roc.Sliceable ByteArray ℕ ByteSlice | true |
SSet.stdSimplex.faceRepresentableBy._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (S : Finset (Fin (n + 1))) (m : ℕ) (e : Fin (m + 1) ≃o ↥S) {j : SimplexCategory}
(f : j ⟶ SimplexCategory.mk m),
∀
x ∈
Finset.image
⇑(SimplexCategory.Hom.toOrderHom
(SSet.stdSimplex.objEquiv
(SSet.stdSimplex.objMk
((OrderHom.Subtype.val fun x => ... | false |
Std.DHashMap.Raw.get?_inter_of_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α}, k ∈ m₂ → (m₁ ∩ m₂).get? k = m₁.get? k | true |
IsAddLeftRegular.all | Mathlib.Algebra.Group.Defs | ∀ {R : Type u_2} [inst : Add R] [IsLeftCancelAdd R] (g : R), IsAddLeftRegular g | true |
stdSimplex.instUniqueElemForall._proof_1 | Mathlib.Analysis.Convex.StdSimplex | ∀ {S : Type u_1} [inst : Semiring S] [inst_1 : PartialOrder S] {X : Type u_2} [IsOrderedRing S] (x : X), 0 ≤ 1 x | false |
WeierstrassCurve.Jacobian.Equation.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Jacobian R) (P : Fin 3 → R),
W'.Equation P = ((MvPolynomial.eval P) W'.polynomial = 0) | true |
Int.fdiv_eq_ediv_of_nonneg | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ) {b : ℤ}, 0 ≤ b → a.fdiv b = a / b | true |
AddMonoidAlgebra.semiring._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddMonoid M] (x : AddMonoidAlgebra R M),
npowRecAuto 0 x = 1 | false |
Lean.findField? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option Lean.Name | true |
Std.DTreeMap.Internal.Impl.size_balanceR | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β} (hlb : l.Balanced)
(hrb : r.Balanced) (hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond r.size l.size),
(Std.DTreeMap.Internal.Impl.balanceR k v l r hlb hrb hlr).size = l.size + 1 + r.size | true |
AList.toFinmap_entries | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} (s : AList β), s.toFinmap.entries = ↑s.entries | true |
SpectralMap.coe_id | Mathlib.Topology.Spectral.Hom | ∀ (α : Type u_2) [inst : TopologicalSpace α], ⇑(SpectralMap.id α) = id | true |
Matrix.toEuclideanLin_apply_piLp_toLp | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_3} [inst : RCLike 𝕜] {m : Type u_7} {n : Type u_8} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
(M : Matrix m n 𝕜) (v : n → 𝕜), (Matrix.toEuclideanLin M) (WithLp.toLp 2 v) = WithLp.toLp 2 (M.mulVec v) | true |
DifferentiableOn.isConservativeOn | Mathlib.Analysis.Complex.HasPrimitives | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : ℂ → E} {U : Set ℂ},
DifferentiableOn ℂ f U → Complex.IsConservativeOn f U | true |
_private.Mathlib.Analysis.Asymptotics.TVS.0.Asymptotics.isLittleOTVS_iff_isLittleO._simp_1_1 | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F} {l : Filter α},
f =o[l] g = ∀ ⦃c : ℝ⦄, 0 < c → ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ | false |
Nat.add_sub_add_right | Init.Data.Nat.Basic | ∀ (n k m : ℕ), n + k - (m + k) = n - m | true |
_private.Lean.Compiler.LCNF.Probing.0.Lean.Compiler.LCNF.Probe.getLetValues.match_1 | Lean.Compiler.LCNF.Probing | (pu : Lean.Compiler.LCNF.Purity) →
(motive : Unit × Array (Lean.Compiler.LCNF.LetValue pu) → Sort u_1) →
(__discr : Unit × Array (Lean.Compiler.LCNF.LetValue pu)) →
((fst : Unit) → (res : Array (Lean.Compiler.LCNF.LetValue pu)) → motive (fst, res)) → motive __discr | false |
Std.Iterators.Types.DropWhile.dropping | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} → Std.Iterators.Types.DropWhile α m β P → Bool | true |
EuclideanSpace.inner_single_right | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] (i : ι) (a : 𝕜)
(v : EuclideanSpace 𝕜 ι), inner 𝕜 v (EuclideanSpace.single i a) = a * (starRingEnd ((fun x => 𝕜) i)) (v.ofLp i) | true |
_private.Mathlib.Data.ENNReal.Inv.0.ENNReal.exists_mem_Ico_zpow._simp_1_1 | Mathlib.Data.ENNReal.Inv | ∀ {r : NNReal}, (↑r = 0) = (r = 0) | false |
Aesop.RuleStats.mk._flat_ctor | Aesop.Stats.Basic | Aesop.DisplayRuleName → Aesop.Nanos → Bool → Aesop.RuleStats | false |
Aesop.GoalData.ctorIdx | Aesop.Tree.Data | {Rapp MVarCluster : Type} → Aesop.GoalData Rapp MVarCluster → ℕ | false |
_private.Mathlib.Algebra.Order.Ring.Int.0.Nat.exists_add_mul_eq_of_gcd_dvd_of_mul_pred_le.match_1_1 | Mathlib.Algebra.Order.Ring.Int | ∀ (q n : ℕ) (motive : q ∣ n → Prop) (x : q ∣ n), (∀ (b : ℕ) (eq : n = q * b), motive ⋯) → motive x | false |
_private.Init.Internal.Order.Lemmas.0.Array.mapM.map.eq_def | Init.Internal.Order.Lemmas | ∀ {α : Type u} {β : Type v} {m : Type v → Type w} [inst : Monad m] (f : α → m β) (as : Array α) (i : ℕ) (bs : Array β),
Array.mapM.map✝ f as i bs =
if hlt : i < as.size then do
let __do_lift ← f as[i]
Array.mapM.map✝¹ f as (i + 1) (bs.push __do_lift)
else pure bs | true |
CategoryTheory.Presieve.HasPairwisePullbacks.casesOn | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
{R : CategoryTheory.Presieve X} →
{motive : R.HasPairwisePullbacks → Sort u} →
(t : R.HasPairwisePullbacks) →
((has_pullbacks :
∀ {Y Z : C} {f : Y ⟶ X}, R f → ∀ {g : Z ⟶ X}, R g → Category... | false |
CategoryTheory.Comma.equivProd_functor_obj | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
(L : CategoryTheory.Functor A (CategoryTheory.Discrete PUnit.{u_1 + 1}))
(R : CategoryTheory.Functor B (CategoryTheory.Discrete PUnit.{u_1 + 1})) (a : CategoryTheory.Comma L R),
(CategoryTheory.... | true |
Array.scanrM.loop._unary | Batteries.Data.Array.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} →
[Monad m] →
(α → β → m β) → (as : Array α) → ℕ → (_ : β) ×' (start : ℕ) ×' (_ : start ≤ as.size) ×' Array β → m (Array β) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.