name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.ComposableArrows.fourδ₁Toδ₀_app_zero | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₁₂ : i₀ ⟶ i₂) (h₁₂ : CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂),
(CategoryTheory.ComposableArrows.fourδ₁Toδ₀ f₁ f₂ f₃ f₄ f₁₂ h₁₂).app 0 = f₁ | true |
FiniteArchimedeanClass.lift_mk | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {α : Type u_2}
(f : { a // a ≠ 0 } → α)
(h : ∀ (a b : { a // a ≠ 0 }), FiniteArchimedeanClass.mk ↑a ⋯ = FiniteArchimedeanClass.mk ↑b ⋯ → f a = f b) {a : M}
(ha : a ≠ 0), FiniteArchimedeanClass.lift f h (FiniteArchime... | true |
FirstOrder.Language.Sentence.cardGe.eq_1 | Mathlib.ModelTheory.Semantics | ∀ (L : FirstOrder.Language) (n : ℕ),
FirstOrder.Language.Sentence.cardGe L n =
(List.foldr (fun x1 x2 => x1 ⊓ x2) ⊤
(List.map
(fun ij =>
(((FirstOrder.Language.var ∘ Sum.inr) ij.1).bdEqual ((FirstOrder.Language.var ∘ Sum.inr) ij.2)).not)
(List.filter (fun ij => decide (ij.1... | true |
DirectLimit.NonUnitalStarRing.of._proof_4 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_1) {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 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonUnitalNonA... | false |
Subsemigroup.instCompleteLattice._proof_14 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M] (x : Subsemigroup M), ∀ x_1 ∈ ⊥, x_1 ∈ x | false |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.instEncodableS | Mathlib.Tactic.DeriveEncodable | Encodable Mathlib.Deriving.Encodable.S✝ | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.entryAtIdx?.match_1.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.lt) (h_2 : Unit → motive Ordering.eq)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.lt with
| Ordering.lt => h_1 ()
| Ordering.eq => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () | true |
Turing.PartrecToTM2.move₂ | Mathlib.Computability.TuringMachine.ToPartrec | (Turing.PartrecToTM2.Γ' → Bool) →
Turing.PartrecToTM2.K' → Turing.PartrecToTM2.K' → Turing.PartrecToTM2.Λ' → Turing.PartrecToTM2.Λ' | true |
Mathlib.Notation3.mkScopedMatcher | Mathlib.Util.Notation3 | Lean.Name →
Lean.Name → Lean.Term → Array Lean.Name → OptionT Lean.Elab.TermElabM (List Mathlib.Notation3.DelabKey × Lean.Term) | true |
_private.Mathlib.Algebra.Lie.Weights.Cartan.0.LieAlgebra.mem_zeroRootSubalgebra._simp_1_1 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ {R : Type u_2} {L : Type u_3} (M : 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 : LieRing.IsNilpotent L] (χ : L → R) (m : M),
(m ∈ LieModule.genWeightSpace M χ) = ∀ (x ... | false |
Lean.Parser.Term.subst.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
Ideal.map_sup_comap_of_surjective | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
[inst_3 : RingHomClass F R S],
Function.Surjective ⇑f → ∀ (I J : Ideal S), Ideal.map f (Ideal.comap f I ⊔ Ideal.comap f J) = I ⊔ J | true |
Homeomorph.mulRight | Mathlib.Topology.Algebra.Group.Basic | {G : Type w} → [inst : TopologicalSpace G] → [inst_1 : Group G] → [SeparatelyContinuousMul G] → G → G ≃ₜ G | true |
CategoryTheory.SimplicialObject.Splitting.toKaroubiNondegComplexIsoN₁_hom_f_PInfty_assoc | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C] {Z : ChainComplex C ℕ}
(h : AlgebraicTopology.AlternatingFaceMapComplex.obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp s.toKaroubiNondegComplexIsoN₁.hom.... | true |
Turing.TM2to1.trStmts₁.eq_3 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (k : K) (f : σ → Option (Γ k) → σ)
(q : Turing.TM2.Stmt Γ Λ σ),
Turing.TM2to1.trStmts₁ (Turing.TM2.Stmt.pop k f q) =
{Turing.TM2to1.Λ'.go k (Turing.TM2to1.StAct.pop f) q, Turing.TM2to1.Λ'.ret q} ∪ Turing.TM2to1.trStmts₁ q | true |
Module.DirectLimit.of._proof_3 | Mathlib.Algebra.Colimit.Module | ∀ (R : Type u_3) [inst : Semiring R] (ι : Type u_1) [inst_1 : Preorder ι] (G : ι → Type u_2)
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j)
[inst_4 : DecidableEq ι] (x : R) (x_1 : DirectSum ι G),
(↑(Module.DirectLimit.moduleCon f).mk').toFun (x... | false |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave'_1 | Init.Tactics | Lean.Macro | false |
Real.analyticOn_cos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {s : Set ℝ}, AnalyticOn ℝ Real.cos s | true |
Subgroup.rightCosetEquivSubgroup | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} → [inst : Group α] → {s : Subgroup α} → (g : α) → ↑(MulOpposite.op g • ↑s) ≃ ↥s | true |
Batteries.RBNode.Balanced.below.black | Batteries.Data.RBMap.Basic | ∀ {α : Type u_1} {motive : (a : Batteries.RBNode α) → (a_1 : Batteries.RBColor) → (a_2 : ℕ) → a.Balanced a_1 a_2 → Prop}
{x : Batteries.RBNode α} {c₁ : Batteries.RBColor} {n : ℕ} {y : Batteries.RBNode α} {c₂ : Batteries.RBColor} {v : α}
(a : x.Balanced c₁ n) (a_1 : y.Balanced c₂ n),
Batteries.RBNode.Balanced.belo... | true |
RatFunc.instCommRing._proof_5 | Mathlib.FieldTheory.RatFunc.Basic | ∀ (K : Type u_1) [inst : CommRing K], Nat.unaryCast 0 = 0 | false |
Set.pi.eq_1 | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} (s : Set ι) (t : (i : ι) → Set (α i)), s.pi t = {f | ∀ i ∈ s, f i ∈ t i} | true |
_private.Init.Data.List.Lemmas.0.List.map_eq_nil_iff.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} (motive : (l : List α) → List.map f l = [] → Prop) (l : List α)
(x : List.map f l = []), (∀ (x : List.map f [] = []), motive [] x) → motive l x | false |
CategoryTheory.Abelian.SpectralObject.d_d._auto_5 | Mathlib.Algebra.Homology.SpectralObject.Differentials | Lean.Syntax | false |
Complex.HadamardThreeLines.norm_invInterpStrip | Mathlib.Analysis.Complex.Hadamard | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (f : ℂ → E) (z : ℂ) {ε : ℝ},
ε > 0 →
‖Complex.HadamardThreeLines.invInterpStrip f z ε‖ =
(ε + Complex.HadamardThreeLines.sSupNormIm f 0) ^ (z.re - 1) *
(ε + Complex.HadamardThreeLines.sSupNormIm f 1) ^ (-z.re) | true |
_private.Init.Meta.Defs.0.Lean.Syntax.getTailInfo?.match_1 | Init.Meta.Defs | (motive : Lean.Syntax → Sort u_1) →
(x : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive (Lean.Syntax.atom info val)) →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(val : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) → motive (Lea... | false |
Set.ncard_lt_card | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α} [Finite α], s ≠ Set.univ → s.ncard < Nat.card α | true |
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra.0.IntermediateField.algebraAdjoinAdjoin.instIsFractionRingSubtypeMemSubalgebraAdjoinAdjoin.match_3 | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ (F : Type u_2) [inst : Field F] {E : Type u_1} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E)
(motive : ↥(IntermediateField.adjoin F S) → Prop) (x : ↥(IntermediateField.adjoin F S)),
(∀ (val : E) (h : val ∈ IntermediateField.adjoin F S), motive ⟨val, h⟩) → motive x | false |
CompHausLike.LocallyConstant.counitAppAppImage | Mathlib.Condensed.Discrete.LocallyConstant | {P : TopCat → Prop} →
[inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)] →
{S : CompHausLike P} →
{Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))} →
[inst_1 : CompHausLike.HasProp P PUnit.{u + 1}] →
(f : LocallyConstant (↑S.toTop) (Y.o... | true |
Finsupp.optionElim | Mathlib.Data.Finsupp.Option | {α : Type u_1} → {M : Type u_2} → [inst : Zero M] → M → (α →₀ M) → Option α →₀ M | true |
Lean.Meta.Grind.Order.modify' | Lean.Meta.Tactic.Grind.Order.Types | (Lean.Meta.Grind.Order.State → Lean.Meta.Grind.Order.State) → Lean.Meta.Grind.GoalM Unit | true |
CategoryTheory.WideSubcategory.instMonoidalCategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Widesubcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.MorphismProperty C)
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : P.IsMonoidalStable]
{X₁ Y₁ X₂ Y₂ : CategoryTheory.WideSubcategory P} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
(CategoryTheory.wideSubcategoryInclusion P).map (CategoryT... | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.mkAndThenSeq._sunfold | Lean.Meta.Tactic.Grind.Split | List (Lean.TSyntax `grind) → Lean.CoreM (Lean.TSyntax `grind) | false |
Lean.Level.imax.injEq | Lean.Level | ∀ (a a_1 a_2 a_3 : Lean.Level), (a.imax a_1 = a_2.imax a_3) = (a = a_2 ∧ a_1 = a_3) | true |
FreeAddMonoid.lift_restrict | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {M : Type u_4} [inst : AddMonoid M] (f : FreeAddMonoid α →+ M),
FreeAddMonoid.lift (⇑f ∘ FreeAddMonoid.of) = f | true |
mul_isLeftRegular_iff._simp_2 | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : Semigroup R] {a : R} (b : R), IsLeftRegular a → IsLeftRegular (a * b) = IsLeftRegular b | false |
Nat.map_add_toList_ric | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n k : ℕ}, List.map (fun x => x + k) (*...=n).toList = (k...=n + k).toList | true |
CoxeterMatrix.E₆._proof_2 | Mathlib.GroupTheory.Coxeter.Matrix | ∀ (i : Fin 6),
!![1, 2, 3, 2, 2, 2; 2, 1, 2, 3, 2, 2; 3, 2, 1, 3, 2, 2; 2, 3, 3, 1, 3, 2; 2, 2, 2, 3, 1, 3; 2, 2, 2, 2, 3, 1] i i = 1 | false |
MeasureTheory.measurable_cylinderEvents_iff | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {α : Type u_1} {ι : Type u_2} {X : ι → Type u_3} {mα : MeasurableSpace α} [m : (i : ι) → MeasurableSpace (X i)]
{Δ : Set ι} {g : α → (i : ι) → X i}, Measurable g ↔ ∀ ⦃i : ι⦄, i ∈ Δ → Measurable fun a => g a i | true |
CategoryTheory.InjectiveResolution.Hom.mk.injEq | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} {I : CategoryTheory.InjectiveResolution Z} {Z' : C}
{I' : CategoryTheory.InjectiveResolution Z'} {f : Z ⟶ Z'} (hom : I.cocomplex ⟶ I'.cocomplex)
(ι_... | true |
Quiver.Path.getElem_vertices_zero._proof_1 | Mathlib.Combinatorics.Quiver.Path.Vertices | ∀ {V : Type u_1} [inst : Quiver V] {a b : V} (p : Quiver.Path a b), 0 < p.vertices.length | false |
HomologicalComplex.natIsoSc'_inv_app_τ₂ | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} (c : ComplexShape ι) (i j k : ι) (hi : c.prev j = i) (hk : c.next j = k) (X : HomologicalComplex C c),
((HomologicalComplex.natIsoSc' C c i j k hi hk).inv.app X).τ₂ = CategoryTheory.Cate... | true |
isStarProjection_iff_eq_starProjection_range | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {p : E →L[𝕜] E},
IsStarProjection p ↔ ∃ (x : (↑p).range.HasOrthogonalProjection), p = (↑p).range.starProjection | true |
ContinuousLinearMap.IsPositive.isSelfAdjoint | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {T : E →L[𝕜] E}, T.IsPositive → IsSelfAdjoint T | true |
_private.Mathlib.LinearAlgebra.Dual.Defs.0.LinearMap.range_dualMap_dual_eq_span_singleton.match_1_3 | Mathlib.LinearAlgebra.Dual.Defs | ∀ {R : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R M₁]
(f m : Module.Dual R M₁) (motive : (∃ a, a • f = m) → Prop) (x : ∃ a, a • f = m),
(∀ (r : R) (hr : r • f = m), motive ⋯) → motive x | false |
Ordinal.uniqueIioOne._proof_1 | Mathlib.SetTheory.Ordinal.Basic | 0 < 1 | false |
CategoryTheory.Limits.Sigma.constCompSigmaIsoConst_hom_app | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasCoproductsOfShape α C] {I : α → Type u_1}
[inst_2 : (i : α) → CategoryTheory.Category.{v_1, u_1} (I i)] (X : α → C) (X_1 : (i : α) → I i),
(CategoryTheory.Limits.Sigma.constCompSigmaIsoConst X).hom.app X_1 = ... | true |
CategoryTheory.Bicategory._aux_Mathlib_CategoryTheory_Bicategory_Adjunction_Basic___unexpand_CategoryTheory_Bicategory_Adjunction_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | Lean.PrettyPrinter.Unexpander | false |
Equiv.permCongrHom_symm | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {β : Type u_5} (e : α ≃ β), e.permCongrHom.symm = e.symm.permCongrHom | true |
ZMod.prime_ne_zero | Mathlib.Data.ZMod.ValMinAbs | ∀ (p q : ℕ) [hp : Fact (Nat.Prime p)] [hq : Fact (Nat.Prime q)], p ≠ q → ↑q ≠ 0 | true |
CategoryTheory.ComposableArrows.Mk₁.obj | Mathlib.CategoryTheory.ComposableArrows.Basic | {C : Type u_1} → C → C → Fin 2 → C | true |
String.Slice.splitInclusive | Init.Data.String.Slice | {ρ : Type} →
{σ : String.Slice → Type} →
(s : String.Slice) → (pat : ρ) → [inst : String.Slice.Pattern.ToForwardSearcher pat σ] → Std.Iter String.Slice | true |
Std.Iterators.Types.Flatten.mk.inj | Init.Data.Iterators.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type w} {m : Type w → Type u_1} {it₁ : Std.IterM m (Std.IterM m β)} {it₂ : Option (Std.IterM m β)}
{it₁_1 : Std.IterM m (Std.IterM m β)} {it₂_1 : Option (Std.IterM m β)},
{ it₁ := it₁, it₂ := it₂ } = { it₁ := it₁_1, it₂ := it₂_1 } → it₁ = it₁_1 ∧ it₂ = it₂_1 | true |
IsPredArchimedean.findAtom | Mathlib.Order.SuccPred.Tree | {α : Type u_1} →
[inst : PartialOrder α] → [inst_1 : PredOrder α] → [IsPredArchimedean α] → [OrderBot α] → [DecidableEq α] → α → α | true |
Lean.Grind.CommRing.Poly.insert.go._f | Init.Grind.Ring.CommSolver | ℤ →
Lean.Grind.CommRing.Mon → (a : Lean.Grind.CommRing.Poly) → Lean.Grind.CommRing.Poly.below a → Lean.Grind.CommRing.Poly | false |
Polynomial.leadingCoeffHom | Mathlib.Algebra.Polynomial.Degree.Operations | {R : Type u} → [inst : Semiring R] → [NoZeroDivisors R] → Polynomial R →* R | true |
WittVector.equiv._proof_1 | Mathlib.RingTheory.WittVector.Compare | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (x y : WittVector p (ZMod p)),
(WittVector.toPadicInt p) (x * y) = (WittVector.toPadicInt p) x * (WittVector.toPadicInt p) y | false |
list_sum_pow_char | Mathlib.Algebra.CharP.Lemmas | ∀ {R : Type u_3} [inst : CommSemiring R] (p : ℕ) [ExpChar R p] (l : List R),
l.sum ^ p = (List.map (fun x => x ^ p) l).sum | true |
CategoryTheory.ShortComplex.FunctorEquivalence.inverse_obj_g | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
(F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)),
((CategoryTheory.ShortComplex.FunctorEquivalence.inverse J C).obj F).g =... | true |
SSet.horn₃₂.desc._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | (SSet.horn 3 2).MulticoequalizerDiagram (fun j => SSet.stdSimplex.face {↑j}ᶜ) fun j k => SSet.stdSimplex.face {↑j, ↑k}ᶜ | false |
Submodule.annihilator_mono | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N P : Submodule R M}, N ≤ P → P.annihilator ≤ N.annihilator | true |
instDecidableEqProd._proof_2 | Init.Core | ∀ {α : Type u_2} {β : Type u_1} (a : α) (b : β) (a' : α) (b' : β), ¬b = b' → (a, b) = (a', b') → False | false |
Std.ExtDTreeMap.maxKeyD_insertIfNew | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k} {fallback : α},
(t.insertIfNew k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' | true |
NormedAddGroupHom.Equalizer.lift.congr_simp | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_2} {V₁ : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
[inst_2 : SeminormedAddCommGroup V₁] {f g : NormedAddGroupHom V W} (φ φ_1 : NormedAddGroupHom V₁ V) (e_φ : φ = φ_1)
(h : f.comp φ = g.comp φ), NormedAddGroupHom.Equalizer.lift φ h = NormedAddGroupHo... | true |
codisjoint_subtype_iff | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {pr : α → Prop},
(∀ ⦃s t : α⦄, pr s → pr t → pr (s ⊔ t)) → ∀ (htop : pr ⊤) {a b : Subtype pr}, Codisjoint a b ↔ Codisjoint ↑a ↑b | true |
_private.Mathlib.RingTheory.IntegralClosure.Algebra.Ideal.0.Polynomial.exists_monic_aeval_eq_zero_forall_mem_of_mem_map._proof_1_2 | Mathlib.RingTheory.IntegralClosure.Algebra.Ideal | ∀ {R : Type u_1} [inst : CommRing R] (p : Polynomial R), ∀ i < p.natDegree, ¬p.natDegree - i = 0 | false |
LinearMap.FiniteRangeSetoid.equiv_iff_isNoetherian_quotient_eqLocus | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V : Type u_2} {V₂ : Type u_4} [inst : CommRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] {u v : V →ₗ[K] V₂},
u ≈ v ↔ IsNoetherian K (V ⧸ LinearMap.eqLocus u v) | true |
Lean.Meta.Grind.AttrKind.cases.sizeOf_spec | Lean.Meta.Tactic.Grind.Attr | ∀ (eager : Bool), sizeOf (Lean.Meta.Grind.AttrKind.cases eager) = 1 + sizeOf eager | true |
Convex.uniformContinuous_gauge | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E},
Convex ℝ s → s ∈ nhds 0 → UniformContinuous (gauge s) | true |
DFinsupp.subset_support_tsub | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[inst_2 : ∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : (i : ι) → Sub (α i)]
[inst_4 : ∀ (i : ι), OrderedSub (α i)] {f g : Π₀ (i : ι), α i} [inst_5 : DecidableEq ι]
[inst_6 : (i : ι) → (x : α i) ... | true |
IsLocallyConstant.iff_is_const | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [PreconnectedSpace X] {f : X → Y},
IsLocallyConstant f ↔ ∀ (x y : X), f x = f y | true |
_private.Mathlib.Data.List.Basic.0.List.foldr_ext._simp_1_4 | Mathlib.Data.List.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | false |
Lean.Lsp.FileChangeType.ctorIdx | Lean.Data.Lsp.Workspace | Lean.Lsp.FileChangeType → ℕ | false |
Std.Sat.AIG.Decl.rec | Std.Sat.AIG.Basic | {α : Type} →
{motive : Std.Sat.AIG.Decl α → Sort u} →
motive Std.Sat.AIG.Decl.false →
((idx : α) → motive (Std.Sat.AIG.Decl.atom idx)) →
((l r : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate l r)) → (t : Std.Sat.AIG.Decl α) → motive t | false |
_private.Lean.Server.Completion.CompletionInfoSelection.0.Lean.Server.Completion.findCompletionInfosAt.containsHoverPos | Lean.Server.Completion.CompletionInfoSelection | String.Pos.Raw → Lean.Elab.CompletionInfo → Bool | true |
SeparationQuotient.instNormedAlgebra._proof_2 | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : NormedField 𝕜] [inst_1 : SeminormedRing E] [inst_2 : NormedAlgebra 𝕜 E],
ContinuousConstSMul 𝕜 E | false |
Equiv.funSplitAt_apply | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} [inst : DecidableEq α] (i : α) (β : Type u_10) (f : (j : α) → (fun a => β) j),
(Equiv.funSplitAt i β) f = (f i, fun j => f ↑j) | true |
_private.Mathlib.Topology.Irreducible.0.isPreirreducible_iff_subset_closure_inter_open.match_1_1 | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} (S a : Set X) (motive : (S ∩ a).Nonempty → Prop) (h : (S ∩ a).Nonempty),
(∀ (p : X) (pS : p ∈ S) (pa : p ∈ a), motive ⋯) → motive h | false |
HurwitzZeta.completedHurwitzZetaEven_zero | Mathlib.NumberTheory.LSeries.RiemannZeta | ∀ (s : ℂ), HurwitzZeta.completedHurwitzZetaEven 0 s = completedRiemannZeta s | true |
Submodule.localized'_inf | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} (S : Type u_2) {M : Type u_3} {N : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Algebra R S] [inst_7 : Module S N] [inst_8 : IsScalarTower R S N] (p : Submonoid R)
[inst_9 : ... | true |
Turing.PartrecToTM2.K'.elim_update_aux | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {a b c d c' : List Turing.PartrecToTM2.Γ'},
Function.update (Turing.PartrecToTM2.K'.elim a b c d) Turing.PartrecToTM2.K'.aux c' =
Turing.PartrecToTM2.K'.elim a b c' d | true |
PolynormableSpace.withSeminorms | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ (𝕜 : Type u_2) (E : Type u_6) [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [PolynormableSpace 𝕜 E], WithSeminorms fun p => ↑p | true |
MeasureTheory.exp_llr | Mathlib.MeasureTheory.Measure.LogLikelihoodRatio | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ],
(fun x => Real.exp (MeasureTheory.llr μ ν x)) =ᵐ[ν] fun x => if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal | true |
Lean.Elab.Deriving.mkInhabitedInstanceHandler | Lean.Elab.Deriving.Inhabited | Array Lean.Name → Lean.Elab.Command.CommandElabM Bool | true |
ProbabilityTheory.mgf_sum_of_identDistrib₀ | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : ι → Ω → ℝ} {s : Finset ι}
{j : ι},
(∀ (i : ι), AEMeasurable (X i) μ) →
ProbabilityTheory.iIndepFun X μ →
(∀ i ∈ s, ∀ j ∈ s, ProbabilityTheory.IdentDistrib (X i) (X j) μ μ) →
j ∈ s → ∀ (t : ℝ), ProbabilityThe... | true |
Finset.singleton_subset_coe._simp_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, ({a} ⊆ ↑s) = ({a} ⊆ s) | false |
Lean.Meta.Match.Overlaps.mk.sizeOf_spec | Lean.Meta.Match.MatcherInfo | ∀ (map : Std.HashMap ℕ (Std.TreeSet ℕ compare)), sizeOf { map := map } = 1 + sizeOf map | true |
CategoryTheory.Limits.BinaryBicone.inlCokernelCofork_π | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} (c : CategoryTheory.Limits.BinaryBicone X Y), CategoryTheory.Limits.Cofork.π c.inlCokernelCofork = c.snd | true |
CategoryTheory.Presheaf.IsSheaf.amalgamate_map_assoc | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] {E : A} {X : C} {P : CategoryTheory.Functor Cᵒᵖ A}
(hP : CategoryTheory.Presheaf.IsSheaf J P) (S : J.Cover X) (x : (I : S.Arrow) → E ⟶ P.obj (Opposite.o... | true |
_private.Init.Data.Range.Polymorphic.UInt.0.UInt64.instLawfulUpwardEnumerableLE._simp_1 | Init.Data.Range.Polymorphic.UInt | ∀ {x y : BitVec 64},
Std.PRange.UpwardEnumerable.LE { toBitVec := x } { toBitVec := y } = Std.PRange.UpwardEnumerable.LE x y | false |
Aesop.BuilderName.forward | Aesop.Rule.Name | Aesop.BuilderName | true |
Lean.Parser.Term.doContinue | Lean.Parser.Do | Lean.Parser.Parser | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.useImplicitLambda | Lean.Elab.Term.TermElabM | Lean.Syntax → Option Lean.Expr → Lean.Elab.TermElabM Lean.Elab.Term.UseImplicitLambdaResult | true |
CategoryTheory.Monad.ForgetCreatesColimits.coconePoint._proof_1 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {D : CategoryTheory.Functor J T.Algebra}
(c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c)
[inst_2 : CategoryTheory.... | false |
Lean.Meta.CaseValuesSubgoal.noConfusion | Lean.Meta.Match.CaseValues | {P : Sort u} → {t t' : Lean.Meta.CaseValuesSubgoal} → t = t' → Lean.Meta.CaseValuesSubgoal.noConfusionType P t t' | false |
TensorPower.gmonoid._proof_1 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(a : GradedMonoid fun i => TensorPower R i M), GradedMonoid.mk (0 • a.fst) (GradedMonoid.GMonoid.gnpowRec 0 a.snd) = 1 | false |
AlgebraicGeometry.ProjIsoSpecTopComponent.ToSpec.carrier._proof_2 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] {f : A},
Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (ProjectiveSpectrum.basicOpen 𝒜 f).inclusion') | false |
Ordinal.ToType.mk._proof_3 | Mathlib.SetTheory.Ordinal.Basic | ∀ {o : Ordinal.{u_1}} (x : ↑(Set.Iio o)), ↑x ∈ Set.Iio (Ordinal.type fun x1 x2 => x1 < x2) | false |
List.hasDecEq.match_1 | Init.Prelude | {α : Type u_1} →
(as bs : List α) →
(motive : Decidable (as = bs) → Sort u_2) →
(x : Decidable (as = bs)) →
((habs : as = bs) → motive (isTrue habs)) → ((nabs : ¬as = bs) → motive (isFalse nabs)) → motive x | false |
Mathlib.Linter.DupNamespaceLinter.initFn._@.Mathlib.Tactic.Linter.Lint.3996576634._hygCtx._hyg.2 | Mathlib.Tactic.Linter.Lint | IO Unit | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.