name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Finset.weightedVSubOfPoint_subtype_eq_filter | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] {ι : Type u_4} (s : Finset ι) (w : ι → k) (p : ι → P) (b : P) (pred : ι → Prop)
[inst_3 : DecidablePred pred],
(((Finset.subtype pred s).weightedVSubOfPoint (fun i => p ↑i) b) fun i => w ↑i) =
({x ∈ s | pred x}.weightedVSubOfPoint p b) w | true |
Lean.Lsp.CompletionItem.label | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CompletionItem → String | true |
nilpotent_iff_lowerCentralSeries | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G], Group.IsNilpotent G ↔ ∃ n, lowerCentralSeries G n = ⊥ | true |
AddConstMapClass.map_fract | Mathlib.Algebra.AddConstMap.Basic | ∀ {F : Type u_1} {H : Type u_3} {b : H} {R : Type u_4} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R]
[inst_3 : AddGroup H] [inst_4 : FunLike F R H] [AddConstMapClass F R H 1 b] (f : F) (x : R),
f (Int.fract x) = f x - ⌊x⌋ • b | true |
_private.Mathlib.FieldTheory.RatFunc.Degree.0.RatFunc.intDegree_mul._simp_1_2 | Mathlib.FieldTheory.RatFunc.Degree | ∀ {G : Type u_3} [inst : AddCommGroup G] {a b c d : G}, (a - b = c - d) = (a + d = c + b) | false |
Complex.norm_eqOn_of_isPreconnected_of_isMaxOn | Mathlib.Analysis.Complex.AbsMax | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {F : Type v} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℂ F] {f : E → F} {U : Set E} {c : E},
IsPreconnected U →
IsOpen U → DifferentiableOn ℂ f U → c ∈ U → IsMaxOn (norm ∘ f) U c → Set.EqOn (norm ∘ f) (Function.const E ‖f c‖) U | true |
Matrix.blockDiag'_zero | Mathlib.Data.Matrix.Block | ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [inst : Zero α], Matrix.blockDiag' 0 = 0 | true |
CategoryTheory.IsPushout.of_forall_isPushout_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F₁ F₂ F₃ F₄ : CategoryTheory.Functor C D} {f₁ : F₁ ⟶ F₂} {f₂ : F₁ ⟶ F₃} {f₃ : F₂ ⟶ F₄} {f₄ : F₃ ⟶ F₄},
(∀ (X : C), CategoryTheory.IsPushout (f₁.app X) (f₂.app X) (f₃.app X) (f₄.app X)) →
CategoryTheory.IsPushout f₁ f₂ f₃ f₄ | true |
_private.Batteries.Data.Int.0.Int.testBit_ofBits_ge._proof_1_5 | Batteries.Data.Int | ∀ {n : ℕ} {i : ℕ} {f : Fin n → Bool}, Nat.ofBits f < 2 ^ n → ¬2 ^ n - Nat.ofBits f - 1 < 2 ^ n → False | false |
Finset.pairwise_sort._simp_1 | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} (s : Finset α) (r : α → α → Prop) [inst : DecidableRel r] [inst_1 : IsTrans α r]
[inst_2 : Std.Antisymm r] [inst_3 : Std.Total r], List.Pairwise r (s.sort r) = True | false |
extDerivWithin | Mathlib.Analysis.Calculus.DifferentialForm.Basic | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] → {n : ℕ} → (E → E [⋀^Fin n]→L[𝕜] F) → Set E → E → E [⋀^Fin (n + 1)]→L[𝕜] F | true |
star_left_conjugate_pos | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{a : R}, 0 < a → ∀ {c : R}, IsRegular c → 0 < star c * a * c | true |
_private.Init.Data.String.PosRaw.0.String.Pos.Raw.lt_of_le_of_lt._simp_1_2 | Init.Data.String.PosRaw | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | false |
FreeAlgebra.instNontrivial | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] [Nontrivial R], Nontrivial (FreeAlgebra R X) | true |
BoolAlg.ofHom_comp | Mathlib.Order.Category.BoolAlg | ∀ {X Y Z : Type u} [inst : BooleanAlgebra X] [inst_1 : BooleanAlgebra Y] [inst_2 : BooleanAlgebra Z]
(f : BoundedLatticeHom X Y) (g : BoundedLatticeHom Y Z),
BoolAlg.ofHom (g.comp f) = CategoryTheory.CategoryStruct.comp (BoolAlg.ofHom f) (BoolAlg.ofHom g) | true |
_private.Mathlib.MeasureTheory.SpecificCodomains.WithLp.0.MeasureTheory.integrable_prodLp_iff._simp_1_1 | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] {f : α → ε}, MeasureTheory.Integrable f μ = MeasureTheory.MemLp f 1 μ | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.minView._proof_6 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (r : Std.DTreeMap.Internal.Impl α β),
r.size = Std.DTreeMap.Internal.Impl.leaf.size + r.size | false |
Lean.Syntax.StrLit | Init.Meta.Defs | Type | true |
NNRat.coe_indicator._simp_1 | Mathlib.Data.NNRat.Lemmas | ∀ {α : Type u_1} (s : Set α) (f : α → ℚ≥0) (a : α), s.indicator (fun x => ↑(f x)) a = ↑(s.indicator f a) | false |
Stream'.WSeq.indexesOf | Mathlib.Data.WSeq.Defs | {α : Type u} → [DecidableEq α] → α → Stream'.WSeq α → Stream'.WSeq ℕ | true |
TannakaDuality.FiniteGroup.mulRepHom._proof_2 | Mathlib.RepresentationTheory.Tannaka | ∀ {k G : Type u_1} [inst : CommRing k], SMulCommClass k (G → k) (G → k) | false |
UniformConvergenceCLM.uniformSpace_eq | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : UniformSpace F] [inst_8 : IsUniformAddGroup F]
(𝔖 : Set (Set E)),
UniformConvergenceCLM.instUniformSpace σ F 𝔖 =
UniformSpace.comap (⇑(UniformOnFun.ofFun 𝔖) ∘ DFunLike.coe) (UniformOnFun.uniformSpace E F 𝔖) | true |
FDRep.forget₂HomLinearEquiv._proof_9 | Mathlib.RepresentationTheory.FDRep | ∀ {R G : Type u_1} [inst : CommRing R] [inst_1 : Monoid G] (X Y : FDRep R G) (x : R)
(x_1 :
(CategoryTheory.forget₂ (FDRep R G) (Rep.{u_1, u_1, u_1} R G)).obj X ⟶
(CategoryTheory.forget₂ (FDRep R G) (Rep.{u_1, u_1, u_1} R G)).obj Y),
{ hom := CategoryTheory.InducedCategory.homMk (ModuleCat.ofHom (Rep.Hom.hom (x • x_1)).toLinearMap), comm := ⋯ } =
{ hom := CategoryTheory.InducedCategory.homMk (ModuleCat.ofHom (Rep.Hom.hom (x • x_1)).toLinearMap), comm := ⋯ } | false |
DiffeologicalSpace.le_iff | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} {d₁ d₂ : DiffeologicalSpace X},
d₁ ≤ d₂ ↔ ∀ (n : ℕ), DiffeologicalSpace.plots n ⊆ DiffeologicalSpace.plots n | true |
_private.Batteries.Lean.LawfulMonadLift.0.EIO.toBaseIO.match_1.splitter | Batteries.Lean.LawfulMonadLift | {ε α : Type} →
(motive : EST.Out ε IO.RealWorld α → Sort u_1) →
(x : EST.Out ε IO.RealWorld α) →
((a : α) → (s : Void IO.RealWorld) → motive (EST.Out.ok a s)) →
((ex : ε) → (s : Void IO.RealWorld) → motive (EST.Out.error ex s)) → motive x | true |
CategoryTheory.Limits.HasCountableCoproducts | Mathlib.CategoryTheory.Limits.Shapes.Countable | (C : Type u_1) → [CategoryTheory.Category.{v_1, u_1} C] → Prop | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey?_minKey._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
ContDiffOn.continuousOn_iteratedDerivWithin | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {s : Set 𝕜} {n : WithTop ℕ∞} {m : ℕ},
ContDiffOn 𝕜 n f s → ↑m ≤ n → UniqueDiffOn 𝕜 s → ContinuousOn (iteratedDerivWithin m f s) s | true |
_private.Mathlib.Combinatorics.SimpleGraph.Prod.0.SimpleGraph.boxProdAssoc._simp_3 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u} {β : Type v} {x y : α × β}, (x = y) = (x.1 = y.1 ∧ x.2 = y.2) | false |
Parser.Attr.rclike_simps_proc | Mathlib.Tactic.Attr.Register | Lean.ParserDescr | true |
SemilinearEquivClass.map_smulₛₗ | Mathlib.Algebra.Module.Equiv.Defs | ∀ {F : Type u_14} {R : outParam (Type u_15)} {S : outParam (Type u_16)} {inst : Semiring R} {inst_1 : Semiring S}
{σ : outParam (R →+* S)} {σ' : outParam (S →+* R)} {inst_2 : RingHomInvPair σ σ'} {inst_3 : RingHomInvPair σ' σ}
{M : outParam (Type u_17)} {M₂ : outParam (Type u_18)} {inst_4 : AddCommMonoid M} {inst_5 : AddCommMonoid M₂}
{inst_6 : Module R M} {inst_7 : Module S M₂} {inst_8 : EquivLike F M M₂} [self : SemilinearEquivClass F σ M M₂]
(f : F) (r : R) (x : M), f (r • x) = σ r • f x | true |
Ordinal.le_cof_type | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {α : Type u} [inst : Preorder α] {c : Cardinal.{u}}, c ≤ Order.cof α ↔ ∀ (s : Set α), IsCofinal s → c ≤ Cardinal.mk ↑s | true |
_private.Lean.Compiler.LCNF.Simp.InlineCandidate.0.Lean.Compiler.LCNF.Simp.inlineCandidate?._sparseCasesOn_18 | Lean.Compiler.LCNF.Simp.InlineCandidate | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.DeclValue pu → Sort u} →
(t : Lean.Compiler.LCNF.DeclValue pu) →
((code : Lean.Compiler.LCNF.Code pu) → motive (Lean.Compiler.LCNF.DeclValue.code code)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Combinatorics.SimpleGraph.AdjMatrix.0.Matrix.compl_of_one_sub_one._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ (α : Type u_1) (V : Type u_2) [inst : AddGroup α] [inst_1 : One α] [inst_2 : DecidableEq V],
Matrix.of 1 - 1 = SimpleGraph.adjMatrix α (SimpleGraph.completeGraph V) | false |
CliffordAlgebra.reverseOp | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | {R : Type u_1} →
[inst : CommRing R] →
{M : Type u_2} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → {Q : QuadraticForm R M} → CliffordAlgebra Q →ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ | true |
QuotientGroup.quotientKerEquivOfSurjective | Mathlib.GroupTheory.QuotientGroup.Basic | {G : Type u} →
[inst : Group G] → {H : Type v} → [inst_1 : Group H] → (φ : G →* H) → Function.Surjective ⇑φ → G ⧸ φ.ker ≃* H | true |
IsContinuousRiemannianBundle | Mathlib.Topology.VectorBundle.Riemannian | {B : Type u_1} →
[inst : TopologicalSpace B] →
(F : Type u_2) →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace ℝ F] →
(E : B → Type u_3) →
[inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] →
[inst_4 : (x : B) → NormedAddCommGroup (E x)] →
[inst_5 : (x : B) → InnerProductSpace ℝ (E x)] →
[inst_6 : FiberBundle F E] → [VectorBundle ℝ F E] → Prop | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.offset_add_slice._proof_1_3 | Init.Data.String.Basic | ∀ {s : String.Slice} {p₀ p₁ : s.Pos},
p₀.offset.byteIdx ≤ p₁.offset.byteIdx →
¬p₀.offset.byteIdx + (p₁.offset.byteIdx - p₀.offset.byteIdx) = p₁.offset.byteIdx → False | false |
CategoryTheory.Equivalence.instMonoidalInverseTrans._proof_22 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_4} [inst_4 : CategoryTheory.Category.{u_3, u_4} E] [inst_5 : CategoryTheory.MonoidalCategory E]
(e : C ≌ D) [inst_6 : e.inverse.Monoidal] (e' : D ≌ E) [inst_7 : e'.inverse.Monoidal],
autoParam
(∀ (X Y : E),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OplaxMonoidal.δ (e.trans e').inverse X Y)
(CategoryTheory.Functor.LaxMonoidal.μ (e.trans e').inverse X Y) =
CategoryTheory.CategoryStruct.id
((e.trans e').inverse.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)))
CategoryTheory.Functor.Monoidal.δ_μ._autoParam | false |
Std.RecursiveMutex._sizeOf_inst | Std.Sync.RecursiveMutex | (α : Type) → [SizeOf α] → SizeOf (Std.RecursiveMutex α) | false |
Nat.le_step | Init.Data.Nat.Basic | ∀ {n m : ℕ}, n ≤ m → n ≤ m.succ | true |
Lean.Expr.ctorIdx | Lean.Expr | Lean.Expr → ℕ | false |
QuadraticAlgebra.instCommSemiring._proof_6 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : CommSemiring R] (a_1 : QuadraticAlgebra R a b), a_1 * 1 = a_1 | false |
_private.Lean.Meta.Tactic.Assert.0.Lean.MVarId.note.match_1 | Lean.Meta.Tactic.Assert | (motive : Option Lean.Expr → Sort u_1) →
(t? : Option Lean.Expr) → ((t : Lean.Expr) → motive (some t)) → (Unit → motive none) → motive t? | false |
UInt32.mod | Init.Data.UInt.Basic | UInt32 → UInt32 → UInt32 | true |
Polynomial.ofFinsupp_single | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (n : ℕ) (r : R),
{ toFinsupp := AddMonoidAlgebra.single n r } = (Polynomial.monomial n) r | true |
Finset.powerset.eq_1 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} (s : Finset α), s.powerset = { val := Multiset.pmap Finset.mk s.val.powerset ⋯, nodup := ⋯ } | true |
JoinedIn | Mathlib.Topology.Connected.PathConnected | {X : Type u_1} → [TopologicalSpace X] → Set X → X → X → Prop | true |
NoZeroDivisors.to_isDomain | Mathlib.Algebra.Ring.Basic | ∀ (α : Type u_3) [inst : Ring α] [h : Nontrivial α] [NoZeroDivisors α], IsDomain α | true |
HasDerivWithinAt.eventually_notMem | Mathlib.Analysis.Calculus.Deriv.Inverse | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {s : Set 𝕜} {x : 𝕜},
HasDerivWithinAt f f' s x →
f' ≠ 0 → ∀ (t : Set F), ¬AccPt (f x) (Filter.principal t) → ∀ᶠ (z : 𝕜) in nhdsWithin x (s \ {x}), f z ∉ t | true |
Mathlib.Tactic.Linarith.Sum.pow._unsafe_rec | Mathlib.Tactic.Linarith.Parsing | Mathlib.Tactic.Linarith.Sum → ℕ → Mathlib.Tactic.Linarith.Sum | false |
CategoryTheory.Equivalence.induced._proof_1 | Mathlib.CategoryTheory.EqToHom | ∀ {D : Type u_1} {T : Type u_2} (e : T ≃ D) {X : D}, e (e.symm X) = X | false |
_private.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.searchPProd._sparseCasesOn_5 | Lean.Elab.PreDefinition.Structural.BRecOn | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Function.iterate_pred_comp_of_pos | Mathlib.Logic.Function.Iterate | ∀ {α : Type u} (f : α → α) {n : ℕ}, 0 < n → f^[n.pred] ∘ f = f^[n] | true |
AlgebraicTopology.DoldKan.compatibility_Γ₂N₁_Γ₂N₂_natTrans | Mathlib.AlgebraicTopology.DoldKan.NCompGamma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] (X : CategoryTheory.SimplicialObject C),
AlgebraicTopology.DoldKan.Γ₂N₁.natTrans.app X =
CategoryTheory.CategoryStruct.comp (AlgebraicTopology.DoldKan.Γ₂N₂ToKaroubiIso.app X).inv
(AlgebraicTopology.DoldKan.Γ₂N₂.natTrans.app
((CategoryTheory.Idempotents.toKaroubi (CategoryTheory.SimplicialObject C)).obj X)) | true |
Array.replicate_succ_ne_empty._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {n : ℕ} {a : α}, (Array.replicate (n + 1) a = #[]) = False | false |
AddEquiv.congr_arg | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] {f : M ≃+ N} {x x' : M}, x = x' → f x = f x' | true |
Lean.Meta.Grind.SplitInfo.ctorElimType | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.SplitInfo → Sort u} → ℕ → Sort (max 1 u) | false |
Submodule.sup_orthogonal_of_hasOrthogonalProjection | Mathlib.Analysis.InnerProductSpace.Projection.Submodule | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{K : Submodule 𝕜 E} [K.HasOrthogonalProjection], K ⊔ Kᗮ = ⊤ | true |
Lean.Quote.recOn | Init.Meta.Defs | {α : Type} →
{k : Lean.SyntaxNodeKind} →
{motive : Lean.Quote α k → Sort u} →
(t : Lean.Quote α k) → ((quote : α → Lean.TSyntax k) → motive { quote := quote }) → motive t | false |
WithZero.instAddMonoid._proof_9 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u_1} [inst : AddSemigroup α] (a : WithZero α), a + 0 = a | false |
Lean.Grind.CommRing.Poly.mul.eq_1 | Init.Grind.Ring.CommSolver | ∀ (p₁ p₂ : Lean.Grind.CommRing.Poly), p₁.mul p₂ = Lean.Grind.CommRing.Poly.mul.go p₂ p₁ (Lean.Grind.CommRing.Poly.num 0) | true |
CategoryTheory.ShortComplex.Hom.comm₁₂_assoc | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (self : S₁.Hom S₂) {Z : C} (h : S₂.X₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp self.τ₁ (CategoryTheory.CategoryStruct.comp S₂.f h) =
CategoryTheory.CategoryStruct.comp S₁.f (CategoryTheory.CategoryStruct.comp self.τ₂ h) | true |
CategoryTheory.functorialSurjectiveInjectiveFactorizationData._proof_2 | Mathlib.CategoryTheory.MorphismProperty.Concrete | ∀ (X : CategoryTheory.Arrow (Type u_1)),
(fun y => ⟨(CategoryTheory.CategoryStruct.id X).right ↑y, ⋯⟩) = CategoryTheory.CategoryStruct.id ↑(Set.range X.hom) | false |
CategoryTheory.EnrichedOrdinaryCategory.noConfusionType | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | Sort u_1 →
{V : Type u'} →
[inst : CategoryTheory.Category.{v', u'} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u} →
[inst_2 : CategoryTheory.Category.{v, u} C] →
CategoryTheory.EnrichedOrdinaryCategory V C →
{V' : Type u'} →
[inst' : CategoryTheory.Category.{v', u'} V'] →
[inst'_1 : CategoryTheory.MonoidalCategory V'] →
{C' : Type u} →
[inst'_2 : CategoryTheory.Category.{v, u} C'] →
CategoryTheory.EnrichedOrdinaryCategory V' C' → Sort u_1 | false |
Std.Iter.toList_flatMap | Init.Data.Iterators.Lemmas.Combinators.FlatMap | ∀ {α α₂ β γ : Type w} [inst : Std.Iterator α Id β] [inst_1 : Std.Iterator α₂ Id γ] [Std.Iterators.Finite α Id]
[Std.Iterators.Finite α₂ Id] [inst : Std.Iterator α Id β] [inst_2 : Std.Iterator α₂ Id γ] [Std.Iterators.Finite α Id]
[Std.Iterators.Finite α₂ Id] {f : β → Std.Iter γ} {it₁ : Std.Iter β},
(Std.Iter.flatMap f it₁).toList = (Std.Iter.map (fun b => (f b).toList) it₁).toList.flatten | true |
_private.Std.Data.DHashMap.Internal.Raw.0.Std.DHashMap.Raw.Const.get?.eq_1 | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (m : Std.DHashMap.Raw α fun x => β) (a : α),
Std.DHashMap.Raw.Const.get? m a =
if h : 0 < m.buckets.size then Std.DHashMap.Internal.Raw₀.Const.get? ⟨m, h⟩ a else none | true |
HasSubset.Subset.iscofinalfor | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s t : Set α}, s ⊆ t → IsCofinalFor s t | true |
Lean.Compiler.LCNF.FindUsed.Context._sizeOf_1 | Lean.Compiler.LCNF.ReduceArity | Lean.Compiler.LCNF.FindUsed.Context → ℕ | false |
CategoryTheory.shrinkYonedaIsoYoneda_inv_app_app | Mathlib.CategoryTheory.ShrinkYoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C) (X_1 : Cᵒᵖ)
(a : (CategoryTheory.yoneda.obj X).obj X_1),
(CategoryTheory.shrinkYonedaIsoYoneda.inv.app X).app X_1 a = CategoryTheory.shrinkYonedaObjObjEquiv.symm a | true |
CategoryTheory.cosimplicialSimplicialEquiv | Mathlib.AlgebraicTopology.SimplicialObject.Basic | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
(CategoryTheory.CosimplicialObject C)ᵒᵖ ≌ CategoryTheory.SimplicialObject Cᵒᵖ | true |
AddSubgroup.isComplement'_top_right | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.IsComplement' ⊤ ↔ H = ⊥ | true |
LinearEquiv.coe_toLinearMap | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂), ⇑↑e = ⇑e | true |
CanLift.prf | Mathlib.Tactic.Lift | ∀ {α : Sort u_1} {β : Sort u_2} {coe : outParam (β → α)} {cond : outParam (α → Prop)} [self : CanLift α β coe cond]
(x : α), cond x → ∃ y, coe y = x | true |
Quaternion.star_mul_self | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), star a * a = ↑(Quaternion.normSq a) | true |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.createImportedEnvironmentSeq.go._unary._proof_1 | Lean.Meta.LazyDiscrTree | ∀ {α : Type} (stop : ℕ) (tree : Lean.Meta.LazyDiscrTree.PreDiscrTree α),
∀ start < stop,
∀ (tree_1 : Lean.Meta.LazyDiscrTree.PreDiscrTree α),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun tree start => stop - start) ⟨tree_1, start + 1⟩
⟨tree, start⟩ | false |
_private.Aesop.Script.Util.0.Aesop.Script.findFirstStep?.match_1 | Aesop.Script.Util | {α β : Type} →
(motive : Option (ℕ × α × β) → Sort u_1) →
(firstStep? : Option (ℕ × α × β)) →
((fst : ℕ) → (fst_1 : α) → (currentFirstStep : β) → motive (some (fst, fst_1, currentFirstStep))) →
((x : Option (ℕ × α × β)) → motive x) → motive firstStep? | false |
HomotopicalAlgebra.instWeakEquivalencePCofibrationsTrivialFibrations | Mathlib.AlgebraicTopology.ModelCategory.Instances | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[inst_2 : HomotopicalAlgebra.CategoryWithCofibrations C] [inst_3 : HomotopicalAlgebra.CategoryWithFibrations C]
{X Y : C} (f : X ⟶ Y)
(h : (HomotopicalAlgebra.cofibrations C).MapFactorizationData (HomotopicalAlgebra.trivialFibrations C) f),
HomotopicalAlgebra.WeakEquivalence h.p | true |
Lean.Lsp.LocationLink.noConfusion | Lean.Data.Lsp.Basic | {P : Sort u} → {t t' : Lean.Lsp.LocationLink} → t = t' → Lean.Lsp.LocationLink.noConfusionType P t t' | false |
Matrix.transposeRingEquiv_symm_apply | Mathlib.Data.Matrix.Basic | ∀ (m : Type u_2) (α : Type u_11) [inst : AddCommMonoid α] [inst_1 : CommMagma α] [inst_2 : Fintype m]
(a : (Matrix m m α)ᵐᵒᵖ), (Matrix.transposeRingEquiv m α).symm a = (MulOpposite.unop a).transpose | true |
WithZero.unzero | Mathlib.Algebra.Group.WithOne.Defs | {α : Type u} → {x : WithZero α} → x ≠ 0 → α | true |
_private.Lean.Elab.BuiltinDo.Match.0.Lean.Elab.Do.elabPatterns | Lean.Elab.BuiltinDo.Match | Array Lean.Syntax → Array Lean.Expr → Lean.Elab.TermElabM (Array Lean.Expr) | true |
Equiv.piEquivPiSubtypeProd._proof_13 | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_2} (p : α → Prop) (β : α → Type u_1) [inst : DecidablePred p],
Function.RightInverse (fun f x => if h : p x then f.1 ⟨x, h⟩ else f.2 ⟨x, h⟩) fun f => (fun x => f ↑x, fun x => f ↑x) | false |
_private.Mathlib.Order.Cover.0.Prod.mk_covBy_mk_iff_right._simp_1_3 | Mathlib.Order.Cover | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {a : α} {b₁ b₂ : β},
((a, b₁) < (a, b₂)) = (b₁ < b₂) | false |
Std.DTreeMap.Internal.Const.RoiSliceData.treeMap | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} → [inst : Ord α] → Std.DTreeMap.Internal.Const.RoiSliceData α β → Std.DTreeMap.Internal.Impl α fun x => β | true |
_private.Mathlib.Analysis.Calculus.LogDeriv.0.logDeriv_fun_zpow._simp_1_7 | Mathlib.Analysis.Calculus.LogDeriv | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | false |
_private.Init.Data.Array.Lemmas.0.Array.foldrM_start_stop._proof_1_3 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {start stop : ℕ}, start ≤ xs.size → stop < start → ¬0 < min start xs.size - stop → False | false |
Order.Frame.recOn | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
{motive : Order.Frame α → Sort u} →
(t : Order.Frame α) →
([toCompleteLattice : CompleteLattice α] →
[toHImp : HImp α] →
(le_himp_iff : ∀ (a b c : α), a ≤ b ⇨ c ↔ a ⊓ b ≤ c) →
[toCompl : Compl α] →
(himp_bot : ∀ (a : α), a ⇨ ⊥ = aᶜ) →
motive
{ toCompleteLattice := toCompleteLattice, toHImp := toHImp, le_himp_iff := le_himp_iff,
toCompl := toCompl, himp_bot := himp_bot }) →
motive t | false |
_private.Mathlib.Topology.TietzeExtension.0.BoundedContinuousFunction.exists_extension_forall_exists_le_ge_of_isClosedEmbedding._simp_1_1 | Mathlib.Topology.TietzeExtension | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | false |
max_sub_sub_right | Mathlib.Algebra.Order.Group.MinMax | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b c : α),
max (a - c) (b - c) = max a b - c | true |
CategoryTheory.MonoOver.liftIso | Mathlib.CategoryTheory.Subobject.MonoOver | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{Y : D} →
{F₁ F₂ : CategoryTheory.Functor (CategoryTheory.Over Y) (CategoryTheory.Over X)} →
(h₁ :
∀ (f : CategoryTheory.MonoOver Y),
CategoryTheory.Mono (F₁.obj ((CategoryTheory.MonoOver.forget Y).obj f)).hom) →
(h₂ :
∀ (f : CategoryTheory.MonoOver Y),
CategoryTheory.Mono (F₂.obj ((CategoryTheory.MonoOver.forget Y).obj f)).hom) →
(F₁ ≅ F₂) → (CategoryTheory.MonoOver.lift F₁ h₁ ≅ CategoryTheory.MonoOver.lift F₂ h₂) | true |
CategoryTheory.instCategoryTransportEnrichment._aux_1 | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | {V : Type u_5} →
[inst : CategoryTheory.Category.{u_3, u_5} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
(C : Type u_2) →
[CategoryTheory.Category.{u_1, u_2} C] →
{W : Type u_6} →
[inst_3 : CategoryTheory.Category.{u_4, u_6} W] →
[inst_4 : CategoryTheory.MonoidalCategory W] →
(F : CategoryTheory.Functor V W) →
[inst_5 : F.LaxMonoidal] → CategoryTheory.Category.{u_1, u_2} (CategoryTheory.TransportEnrichment F C) | false |
StieltjesFunction.measure_botSet | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f : StieltjesFunction R)
[inst_2 : OrderTopology R] [inst_3 : CompactIccSpace R] [inst_4 : MeasurableSpace R] [inst_5 : BorelSpace R]
[inst_6 : SecondCountableTopology R] [inst_7 : DenselyOrdered R], f.measure botSet = 0 | true |
CategoryTheory.RelCat.rel_iso_iff | Mathlib.CategoryTheory.Category.RelCat | ∀ {X Y : CategoryTheory.RelCat} (r : X ⟶ Y),
CategoryTheory.IsIso r ↔ ∃ f, CategoryTheory.RelCat.graphFunctor.map f.hom = r | true |
Int.negSucc_mul_ofNat | Init.Data.Int.Lemmas | ∀ (m n : ℕ), Int.negSucc m * ↑n = -↑(m.succ * n) | true |
_private.Mathlib.Order.BooleanSubalgebra.0.BooleanSubalgebra.mem_closure_iff_sup_sdiff.match_1_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] {s : Set α} (t : Finset (↑s × ↑s))
(motive : (∃ t_1, (t.sup fun x => ↑x.1 \ ↑x.2)ᶜ = t_1.sup fun x => ↑x.1 \ ↑x.2) → Prop)
(x : ∃ t_1, (t.sup fun x => ↑x.1 \ ↑x.2)ᶜ = t_1.sup fun x => ↑x.1 \ ↑x.2),
(∀ (tc : Finset (↑s × ↑s)) (eq : (t.sup fun x => ↑x.1 \ ↑x.2)ᶜ = tc.sup fun x => ↑x.1 \ ↑x.2), motive ⋯) → motive x | false |
RingOfIntegers.ZModXQuotSpanEquivQuotSpanPair._proof_9 | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {K : Type u_1} [inst : Field K] {θ : NumberField.RingOfIntegers K} {p : ℕ} {Q : Polynomial ℤ},
(Ideal.span {↑p} ⊔ Ideal.span {(Polynomial.aeval θ) Q}).IsTwoSided | false |
_private.Init.Data.Range.Polymorphic.Map.0.Std.PRange.LawfulUpwardEnumerableLT.ofMap._simp_1_1 | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u} {inst : Std.PRange.UpwardEnumerable α} {inst_1 : LT α} [self : Std.PRange.LawfulUpwardEnumerableLT α]
(a b : α), (a < b) = Std.PRange.UpwardEnumerable.LT a b | false |
Lean.PrettyPrinter.categoryParenthesizerAttribute | Lean.PrettyPrinter.Parenthesizer | Lean.KeyedDeclsAttribute Lean.PrettyPrinter.CategoryParenthesizer | true |
_private.Mathlib.Topology.Spectral.ConstructibleTopology.0.compactSpace_withConstructibleTopology._proof_16 | Mathlib.Topology.Spectral.ConstructibleTopology | ∀ {X : Type u_1} [inst : TopologicalSpace X] (B : Set (Set X)),
Maximal (fun x => x ∈ {P | P ⊆ constructibleTopologySubbasis X ∧ (∀ Q ⊆ P, Q.Finite → (⋂₀ Q).Nonempty) ∧ ⋂₀ P = ∅})
B →
∀ (Y₁ Y₂ : Set X), ∀ A₁ ⊆ insert Y₁ B, ∀ A₂ ⊆ insert Y₂ B, A₁ \ {Y₁} ∪ A₂ \ {Y₂} ⊆ constructibleTopologySubbasis X | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.