name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
HomologicalComplex₂.ιTotal_totalFlipIso_f_hom_assoc | Mathlib.Algebra.Homology.TotalComplexSymmetry | ∀ {C : Type u_1} {I₁ : Type u_2} {I₂ : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Preadditive C] {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂}
(K : HomologicalComplex₂ C c₁ c₂) (c : ComplexShape J) [inst_2 : TotalComplexShape c₁ c₂ c]
[inst_3 : TotalComplexShap... | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.monoidalOppositeLeftAction._proof_6 | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_4) [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {c c' c'' : Cᴹᵒᵖ} {d d' d'' : D} (f₁ : c ⟶ c')
(f₂ : c' ⟶ c'') (g₁ : d ⟶ d')... | null | false |
Nat.coprime_two_right._simp_1 | Mathlib.Data.Nat.Prime.Basic | ∀ {n : ℕ}, n.Coprime 2 = Odd n | null | false |
MvPowerSeries.HasGaussNorm | Mathlib.RingTheory.MvPowerSeries.GaussNorm | {R : Type u_1} → {σ : Type u_2} → (R → ℝ) → (σ → ℝ) → MvPowerSeries σ R → [Semiring R] → Prop | We say `f` HasGaussNorm if the values `v (coeff t f) * ∏ i : t.support, c i` is bounded above,
that is `gaussNorm f` is finite. | true |
SheafOfModules.QuasicoherentData.IsFinitePresentation.isFinite_presentation | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} {inst_1 : ∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat}
{inst_2 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat} {M : SheafOfModules R}
{... | null | true |
Std.Iter.findSomeM?_eq_match_step.match_1 | Init.Data.Iterators.Lemmas.Consumers.Loop | {γ : Type u_1} →
(motive : Option γ → Sort u_2) →
(__do_lift : Option γ) → (Unit → motive none) → ((fx : γ) → motive (some fx)) → motive __do_lift | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_congr._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Init.Data.Int.Cooper.0.Int.Cooper.resolve_left_inv.eq_1 | Init.Data.Int.Cooper | ∀ (a p k : ℤ), Int.Cooper.resolve_left_inv a p k = (k + p) / a | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Goal.getEqcs._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Types | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
IsManifold.maximalAtlas | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
ModelWithCorners 𝕜 E H →
WithTop ℕ∞ →
(M : ... | The maximal atlas of `M` for the `C^n` manifold with corners structure corresponding to the
model with corners `I`. | true |
Aesop.PhaseSpec.unsafe.elim | Aesop.Builder.Basic | {motive : Aesop.PhaseSpec → Sort u} →
(t : Aesop.PhaseSpec) →
t.ctorIdx = 2 → ((info : Aesop.UnsafeRuleInfo) → motive (Aesop.PhaseSpec.unsafe info)) → motive t | null | false |
mem_lowerBounds_image2 | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ] {f : α → β → γ}
{s : Set α} {t : Set β} {a : α} {b : β},
(∀ (b : β), Monotone (Function.swap f b)) →
(∀ (a : α), Monotone (f a)) → a ∈ lowerBounds s → b ∈ lowerBounds t → f a b ∈ lowerBounds (Set.image2 f s ... | null | true |
gauge_neg_set_neg | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} (x : E), gauge (-s) (-x) = gauge s x | null | true |
MvPowerSeries.coeff_zero_eq_constantCoeff_apply | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (φ : MvPowerSeries σ R),
(MvPowerSeries.coeff 0) φ = MvPowerSeries.constantCoeff φ | null | true |
Polynomial.coeff_divByMonic_X_sub_C | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : Ring R] (p : Polynomial R) (a : R) (n : ℕ),
(p /ₘ (Polynomial.X - Polynomial.C a)).coeff n = ∑ i ∈ Finset.Icc (n + 1) p.natDegree, a ^ (i - (n + 1)) * p.coeff i | null | true |
MeasureTheory.MemLp.zero | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} {ε : Type u_8}
[inst : TopologicalSpace ε] [inst_1 : ESeminormedAddMonoid ε], MeasureTheory.MemLp 0 p μ | null | true |
Lean.Grind.CommRing.Poly.mulMonC_nc.go | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Mon → ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | null | true |
Combinatorics.Subspace.reindex | Mathlib.Combinatorics.HalesJewett | {η : Type u_5} →
{α : Type u_6} →
{ι : Type u_7} →
{η' : Type u_9} →
{α' : Type u_10} →
{ι' : Type u_11} → Combinatorics.Subspace η α ι → η ≃ η' → α ≃ α' → ι ≃ ι' → Combinatorics.Subspace η' α' ι' | Change the index types of a subspace. | true |
_private.Std.Data.Internal.List.Associative.0.List.forIn'_cons.match_1.splitter | Std.Data.Internal.List.Associative | {β : Type u_1} →
(motive : ForInStep β → Sort u_2) →
(x : ForInStep β) → ((b : β) → motive (ForInStep.done b)) → ((b : β) → motive (ForInStep.yield b)) → motive x | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.fixupBlock._unsafe_rec | Lean.Elab.DocString | Lean.Doc.Block Lean.ElabInline Lean.ElabBlock → Lean.Doc.DocM (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) | null | false |
CliffordAlgebra.GradedAlgebra.ι_apply | Mathlib.LinearAlgebra.CliffordAlgebra.Grading | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) (m : M),
(CliffordAlgebra.GradedAlgebra.ι Q) m =
(DirectSum.of (fun i => ↥(CliffordAlgebra.evenOdd Q i)) 1) ⟨(CliffordAlgebra.ι Q) m, ⋯⟩ | null | true |
GenContFract.abs_sub_convs_le | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} {v : K} {n : ℕ} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K]
[inst_3 : FloorRing K],
¬(GenContFract.of v).TerminatedAt n →
|v - (GenContFract.of v).convs n| ≤ 1 / ((GenContFract.of v).dens n * (GenContFract.of v).dens (n + 1)) | Shows that `|v - Aₙ / Bₙ| ≤ 1 / (Bₙ * Bₙ₊₁)`. | true |
SimpleGraph.Walk.isHamiltonian_iff_support_get_bijective | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a b : α} {p : G.Walk a b},
p.IsHamiltonian ↔ Function.Bijective p.support.get | null | true |
Pell.yn_succ | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (n : ℕ), Pell.yn a1 (n + 1) = Pell.xn a1 n + Pell.yn a1 n * a | null | true |
_private.Lean.LocalContext.0.Lean.LocalContext.findFromUserNames.match_1 | Lean.LocalContext | {α : Type} →
(motive : Std.HashMap Lean.Name α × Array Lean.LocalDecl → Sort u_1) →
(x : Std.HashMap Lean.Name α × Array Lean.LocalDecl) →
((userNames : Std.HashMap Lean.Name α) → (acc : Array Lean.LocalDecl) → motive (userNames, acc)) → motive x | null | false |
Aesop.EMap.idx | Aesop.EMap | {α : Type u_1} → Aesop.EMap α → Lean.Meta.DiscrTree ℕ | An index for `rep`. For each expression `e` at index `i` in `rep`,
`idx.getMatch` returns a list of indexes containing `i`. This is used as a
pre-filter during lookups/insertions/modifications to reduce the number of
defeq comparisons. | true |
DivInvMonoid.zpow_succ'._autoParam | Mathlib.Algebra.Group.DivInvMonoid | Lean.Syntax | null | false |
Topology.lowerSet._proof_2 | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ (α : Type u_1) [inst : Preorder α] (x x_1 : Set α), IsLowerSet x → IsLowerSet x_1 → IsLowerSet (x ∩ x_1) | null | false |
Std.HashMap.Raw.erase | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → Std.HashMap.Raw α β → α → Std.HashMap.Raw α β | Removes the mapping for the given key if it exists. | true |
CategoryTheory.ComposableArrows.whiskerLeftFunctor_obj_obj | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n m : ℕ}
(Φ : CategoryTheory.Functor (Fin (n + 1)) (Fin (m + 1))) (F : CategoryTheory.ComposableArrows C m) (X : Fin (n + 1)),
((CategoryTheory.ComposableArrows.whiskerLeftFunctor Φ).obj F).obj X = F.obj (Φ.obj X) | null | true |
SSet.Edge.CompStruct.mk._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | ∀ {X : SSet} {x₀ x₂ : X.obj (Opposite.op { len := 0 })} {e₀₂ : SSet.Edge x₀ x₂}
(simplex : X.obj (Opposite.op { len := 2 })),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.δ X 1)) simplex = e₀₂.edge →
(CategoryTheory.ConcreteCategory.hom
(((SSet.truncation 2).obj X).map
... | null | false |
MvPowerSeries.lexOrder_mul_ge | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : LinearOrder σ] [inst_2 : WellFoundedGT σ]
(φ ψ : MvPowerSeries σ R), φ.lexOrder + ψ.lexOrder ≤ (φ * ψ).lexOrder | **Alias** of `MvPowerSeries.le_lexOrder_mul`. | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.WeierstrassCurve.Affine.CoordinateRing.smul_basis_mul_Y._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a = a ^ 2 | null | false |
_private.Batteries.Data.List.Basic.0.List.rotate'.match_1.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → ℕ → Sort u_2) (x : ℕ) (h_1 : (x : ℕ) → motive [] x)
(h_2 : (l : List α) → motive l 0) (h_3 : (a : α) → (l : List α) → (n : ℕ) → motive (a :: l) n.succ),
(match [], x with
| [], x => h_1 x
| l, 0 => h_2 l
| a :: l, n.succ => h_3 a l n) =
h_1 x | null | true |
CategoryTheory.Triangulated.TStructure.essImage_ιHeart | Mathlib.CategoryTheory.Triangulated.TStructure.Heart | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | null | true |
String.Slice.Pattern.ForwardPattern.skipPrefixOfNonempty?._default | Init.Data.String.Pattern.Basic | {ρ : Type} → {pat : ρ} → ((s : String.Slice) → Option s.Pos) → (s : String.Slice) → s.isEmpty = false → Option s.Pos | null | false |
Lean.Syntax.formatStx | Init.Data.Format.Syntax | Lean.Syntax → optParam (Option ℕ) none → optParam Bool false → Std.Format | Pretty print the given syntax `stx` as a `Format`.
Nodes deeper than `maxDepth` are omitted.
Setting the `showInfo` flag will also print the `SourceInfo` for each node. | true |
_private.Lean.Compiler.LCNF.AlphaEqv.0.Lean.Compiler.LCNF.AlphaEqv.eqv.match_1 | Lean.Compiler.LCNF.AlphaEqv | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.Code pu → Sort u_1) →
(code₁ code₂ : Lean.Compiler.LCNF.Code pu) →
((decl₁ : Lean.Compiler.LCNF.LetDecl pu) →
(k₁ : Lean.Compiler.LCNF.Code pu) →
(decl₂ : Lean.Compiler.LCNF.LetDecl pu) →
... | null | false |
AlgHom.comp | Mathlib.Algebra.Algebra.Hom | {R : Type u} →
{A : Type v} →
{B : Type w} →
{C : Type u₁} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Semiring C] →
[inst_4 : Algebra R A] →
[inst_5 : Algebra R B] → [inst_6 : Algebra R C... | If `φ₁` and `φ₂` are `R`-algebra homomorphisms with the
domain of `φ₁` equal to the codomain of `φ₂`, then
`φ₁.comp φ₂` is the algebra homomorphism `x ↦ φ₁ (φ₂ x)`.
| true |
ULift.divisionSemiring._proof_1 | Mathlib.Algebra.Field.ULift | ∀ {α : Type u_2} [inst : DivisionSemiring α] (a b : ULift.{u_1, u_2} α), a / b = a * b⁻¹ | null | false |
CategoryTheory.Limits.Types.pullbackLimitCone._proof_4 | Mathlib.CategoryTheory.Limits.Types.Pullbacks | ∀ {X Y Z : Type u_1} (f : X ⟶ Z) (g : Y ⟶ Z) (s : CategoryTheory.Limits.PullbackCone f g),
CategoryTheory.CategoryStruct.comp
(TypeCat.ofHom fun x =>
⟨((CategoryTheory.ConcreteCategory.hom s.fst) x, (CategoryTheory.ConcreteCategory.hom s.snd) x), ⋯⟩)
(CategoryTheory.Limits.Types.pullbackCone f g).... | null | false |
ProbabilityTheory.Kernel.condKernelCountable.congr_simp | Mathlib.Probability.Kernel.Disintegration.Basic | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mΩ : MeasurableSpace Ω} [inst : Countable α] (κCond κCond_1 : α → ProbabilityTheory.Kernel β Ω)
(e_κCond : κCond = κCond_1) (h_atom : ∀ (x y : α), x ∈ measurableAtom y → κCond x = κCond y),
ProbabilityTheory.Kernel.c... | null | true |
HomologicalComplex.isStrictlySupported_mapHomologicalComplex_obj_iff | Mathlib.Algebra.Homology.Embedding.IsSupported | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3} {D : Type u_4}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Category.{v_2, u_4} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(K : Homo... | null | true |
uzpow_sub | Mathlib.Data.ZMod.IntUnitsPower | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : Module R (Additive ℤˣ)] (s : ℤˣ) (x y : R), s ^ (x - y) = s ^ x / s ^ y | null | true |
CategoryTheory.Functor.PreservesRightKanExtension.mk' | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B... | Alternative constructor for `PreservesRightKanExtension`, phrased in terms of
`RightExtension.IsUniversal` instead. See `PreservesRightKanExtension.mk_of_preserves_isUniversal`
for a similar constructor taking as input a single `RightExtension`. | true |
Std.PRange.UpwardEnumerable.Map.PreservesRxiSize.mk | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.UpwardEnumerable β]
[inst_2 : Std.Rxi.HasSize α] [inst_3 : Std.Rxi.HasSize β] {f : Std.PRange.UpwardEnumerable.Map α β},
(∀ {b : α}, Std.Rxi.HasSize.size b = Std.Rxi.HasSize.size (f.toFun b)) → f.PreservesRxiSize | null | true |
Int32.not_lt._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int32}, (¬a < b) = (b ≤ a) | null | false |
tsum_indicator_of_mem_union_disjoint | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (s : γ → Set β)
(f : β → α), Pairwise (Function.onFun Disjoint s) → ∀ i ∈ ⋃ d, s d, ∑' (d : γ), (s d).indicator f i = f i | null | true |
Lean.Compiler.LCNF.FloatLetIn.FloatState.newArms | Lean.Compiler.LCNF.FloatLetIn | Lean.Compiler.LCNF.FloatLetIn.FloatState →
Std.HashMap Lean.Compiler.LCNF.FloatLetIn.Decision (List (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure)) | A map from decisions (excluding `unknown`) to the declarations with
these decisions (in correct order). Basically:
- Which declarations do we not move
- Which declarations do we move into a certain arm
- Which declarations do we move into the default arm
| true |
Lean.instBEqModuleIdx | Lean.Environment | BEq Lean.ModuleIdx | null | true |
_private.Lean.Meta.CoeAttr.0.Lean.Meta.registerCoercion.match_1 | Lean.Meta.CoeAttr | (motive : Option ℕ → Sort u_1) →
(x : Option ℕ) → ((coercee : ℕ) → motive (some coercee)) → ((x : Option ℕ) → motive x) → motive x | null | false |
LieAdmissibleAlgebra.mk.noConfusion | Mathlib.Algebra.NonAssoc.LieAdmissible.Defs | {R : Type u_1} →
{L : Type u_2} →
{inst : CommRing R} →
{inst_1 : LieAdmissibleRing L} →
{P : Sort u} →
{toModule : Module R L} →
{toIsScalarTower : IsScalarTower R L L} →
{toSMulCommClass : SMulCommClass R L L} →
{toModule' : Module R L} →
... | null | false |
CategoryTheory.Span.SpanBicat.comp_hom_ext_apex_iff | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | true |
CategoryTheory.Limits.WidePullbackShape.uliftEquivalence | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} →
CategoryTheory.ULiftHom (ULift.{w', w} (CategoryTheory.Limits.WidePullbackShape J)) ≌
CategoryTheory.Limits.WidePullbackShape (ULift.{w', w} J) | Lifting universe and morphism levels preserves wide pullback diagrams. | true |
GradedAlgHom.toGradedRingHom_ofClass | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {ι : Type u_6} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : DecidableEq ι] [inst_6 : AddMonoid ι]
{𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B} [inst_7 : GradedAlgebra 𝒜] [inst_8 : Grade... | null | true |
TopologicalSpace.Opens.instCompleteLattice._proof_4 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] (a b : TopologicalSpace.Opens α), { carrier := ↑a ∩ ↑b, is_open' := ⋯ } ≤ a | null | false |
CategoryTheory.colimitYonedaHomEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Indization.LocallySmall | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} C] {I : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} I] [CategoryTheory.Limits.HasLimitsOfShape Iᵒᵖ (Type u_4)]
(F : CategoryTheory.Functor I C) (G : CategoryTheory.Functor Cᵒᵖ (Type u_4)),
CategoryTheory.Limits.HasLimit ((F.op.comp G).comp Cat... | null | false |
Valuation.RankLeOne.rankOne_of_nontrivial._proof_1 | Mathlib.RingTheory.Valuation.RankOne | ∀ {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {K : Type u_1} [inst_1 : DivisionRing K]
(v : Valuation K Γ₀), Nontrivial (↑v).ValueGroup₀ˣ → ∃ x, v x ≠ 0 ∧ v x ≠ 1 | null | false |
BitVec.toFin_setWidth | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ} {x : BitVec w}, (BitVec.setWidth v x).toFin = Fin.ofNat (2 ^ v) x.toNat | null | true |
Nat.bitwise_zero_right | Mathlib.Data.Nat.Bitwise | ∀ {f : Bool → Bool → Bool} (n : ℕ), Nat.bitwise f n 0 = if f true false = true then n else 0 | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups.0.alternatingGroup.isCoatom_stabilizer_of_ncard_lt_ncard_compl._proof_1_1 | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} {s : Set α}, 1 < s.ncard → s.ncard < sᶜ.ncard → s.ncard + sᶜ.ncard = Nat.card α → 4 < Nat.card α | null | false |
List.reduceOption_concat | Mathlib.Data.List.ReduceOption | ∀ {α : Type u_1} (l : List (Option α)) (x : Option α), (l.concat x).reduceOption = l.reduceOption ++ x.toList | null | true |
Lean.Syntax.node8 | Init.Prelude | Lean.SourceInfo →
Lean.SyntaxNodeKind →
Lean.Syntax →
Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax | Create syntax node with 8 children | true |
CategoryTheory.Functor.isColimitOfIsWellOrderContinuous' | Mathlib.CategoryTheory.Limits.Shapes.Preorder.WellOrderContinuous | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : PartialOrder J] →
(F : CategoryTheory.Functor J C) →
[F.IsWellOrderContinuous] →
{α : Type u_1} →
[inst_3 : PartialOrder α] →
(f : α <i J) → Order.IsSuccLimit f.top... | If `F : J ⥤ C` is well-order-continuous and `h : α <i J` is a principal
segment such that `h.top` is a limit element, then
`F.obj h.top` identifies to the colimit of the `F.obj j` for `j : α`. | true |
ExteriorAlgebra.liftAlternatingEquiv._proof_2 | Mathlib.LinearAlgebra.ExteriorAlgebra.OfAlternating | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N] (x y : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N),
ExteriorAlgebra.liftAlternating (x + y) = ExteriorAlgebra.liftAlternating x + ExteriorAlgebra.liftAlternating y | null | false |
KaehlerDifferential.mvPolynomialBasis_repr_symm_single | Mathlib.RingTheory.Kaehler.Polynomial | ∀ (R : Type u) [inst : CommRing R] (σ : Type u_1) (i : σ) (x : MvPolynomial σ R),
((KaehlerDifferential.mvPolynomialBasis R σ).repr.symm fun₀ | i => x) =
x • (KaehlerDifferential.D R (MvPolynomial σ R)) (MvPolynomial.X i) | null | true |
CategoryTheory.GlueData.types_π_surjective | Mathlib.CategoryTheory.GlueData | ∀ (D : CategoryTheory.GlueData (Type u_1)), Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom D.π) | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Basic.0.SSet.Subcomplex.Pairing.anodyneExtensions._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : CategoryTheory.MorphismProperty C}
[Q.IsStableUnderCobaseChange], (P.pushouts ≤ Q) = (P ≤ Q) | null | false |
Mathlib.Tactic.BicategoryLike.Mor₁.id | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Lean.Expr → Mathlib.Tactic.BicategoryLike.Obj → Mathlib.Tactic.BicategoryLike.Mor₁ | `id e a` is the expression for `𝟙 a`, where `e` is the underlying lean expression. | true |
_private.Std.Data.TreeMap.Lemmas.0.Std.TreeMap.Equiv.symm.match_1_1 | Std.Data.TreeMap.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} (motive : t₁.Equiv t₂ → Prop)
(x : t₁.Equiv t₂), (∀ (h : t₁.inner.Equiv t₂.inner), motive ⋯) → motive x | null | false |
Subgroup.IsSubnormal.trans | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G},
H ≤ K → (H.subgroupOf K).IsSubnormal → K.IsSubnormal → H.IsSubnormal | If `H` is a subnormal subgroup of `K` and `K` is a subnormal subgroup of `G`,
then `H` is a subnormal subgroup of `G`.
| true |
CategoryTheory.IsGrothendieckAbelian.tensorObj | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.GabrielPopescu | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[CategoryTheory.IsGrothendieckAbelian.{v, v, u} C] →
(G : C) → CategoryTheory.Functor (ModuleCat (CategoryTheory.End G)ᵐᵒᵖ) C | The left adjoint of the functor `Hom(G, ·)`, which can be thought of as `· ⊗ G`. | true |
Lean.Lsp.LeanClientCapabilities.incrementalDiagnosticSupport?._default | Lean.Data.Lsp.Capabilities | Option Bool | null | false |
LinearMap.normDet_eq_abs_det | Mathlib.Analysis.InnerProductSpace.NormDet | ∀ {U : Type u_5} [inst : NormedAddCommGroup U] [inst_1 : InnerProductSpace ℝ U] [inst_2 : FiniteDimensional ℝ U]
(f : U →ₗ[ℝ] U), f.normDet = |LinearMap.det f| | null | true |
Lean.Compiler.LCNF.JoinPointContextExtender.ExtendState.mk | Lean.Compiler.LCNF.JoinPoints | Std.HashMap Lean.FVarId (Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) →
Lean.Compiler.LCNF.JoinPointContextExtender.ExtendState | null | true |
WithTop.untopD_add | Mathlib.Algebra.Order.WithTop.Untop0 | ∀ {α : Type u_1} [inst : Add α] {a b : WithTop α} {c : α},
a ≠ ⊤ → b ≠ ⊤ → WithTop.untopD c (a + b) = WithTop.untopD c a + WithTop.untopD c b | null | true |
_private.Lean.Meta.Tactic.Grind.EqResolution.0.Lean.Meta.Grind.topsortMVars?.visit | Lean.Meta.Tactic.Grind.EqResolution | Array Lean.Expr → Lean.Expr → Lean.Meta.Grind.TopSortM Unit | null | true |
CategoryTheory.Limits.BinaryBiproductData.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{P Q : C} →
(bicone : CategoryTheory.Limits.BinaryBicone P Q) →
bicone.IsBilimit → CategoryTheory.Limits.BinaryBiproductData P Q | null | false |
Lean.Grind.Ring.OfSemiring.add | Init.Grind.Ring.Envelope | {α : Type u} →
[inst : Lean.Grind.Semiring α] →
Lean.Grind.Ring.OfSemiring.Q α → Lean.Grind.Ring.OfSemiring.Q α → Lean.Grind.Ring.OfSemiring.Q α | null | true |
posPart_pos_iff._simp_1 | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α} [inst_1 : SubNegMonoid α], (0 < a⁺) = (0 < a) | null | false |
Lean.Meta.instReduceEvalName | Lean.Meta.ReduceEval | Lean.Meta.ReduceEval Lean.Name | null | true |
Nat.modulus_mul_add_modEq_iff | Mathlib.Data.Nat.ModEq | ∀ {n a b c : ℕ}, n * b + a ≡ c [MOD n] ↔ a ≡ c [MOD n] | null | true |
Lean.Level.PP.Context.mk.sizeOf_spec | Lean.Level | ∀ (mvars : Bool) (lIndex? : Lean.LMVarId → Option ℕ), sizeOf { mvars := mvars, lIndex? := lIndex? } = 1 + sizeOf mvars | null | true |
Lean.Core.checkInterrupted | Lean.CoreM | Lean.CoreM Unit | Throws an internal interrupt exception if cancellation has been requested. The exception is not
caught by `try catch` but is intended to be caught by `Command.withLoggingExceptions` at the top
level of elaboration. In particular, we want to skip producing further incremental snapshots after
the exception has been throw... | true |
Flag._sizeOf_inst | Mathlib.Order.Preorder.Chain | (α : Type u_4) → {inst : LE α} → [SizeOf α] → SizeOf (Flag α) | null | false |
ContinuousMonoidHom.continuous_comp_left | Mathlib.Topology.Algebra.Group.CompactOpen | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : Monoid C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] (f : A →ₜ* B),
Continuous fun g => g.comp f | null | true |
finprod_mem_image | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : CommMonoid M] {f : α → M} {s : Set β} {g : β → α},
Set.InjOn g s → ∏ᶠ (i : α) (_ : i ∈ g '' s), f i = ∏ᶠ (j : β) (_ : j ∈ s), f (g j) | The product of `f y` over `y ∈ g '' s` equals the product of `f (g i)` over `s` provided that
`g` is injective on `s`. | true |
LowerSet.coe_bot | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], ↑⊥ = ∅ | null | true |
_private.Mathlib.Combinatorics.Matroid.Rank.ENat.0.Matroid.eRk_le_one_iff.match_1_1 | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {X : Set α} (motive : (∃ e ∈ M.E, X ⊆ M.closure {e}) → Prop)
(x : ∃ e ∈ M.E, X ⊆ M.closure {e}), (∀ (e : α) (left : e ∈ M.E) (he : X ⊆ M.closure {e}), motive ⋯) → motive x | null | false |
List.sublists_append | Mathlib.Data.List.Sublists | ∀ {α : Type u} (l₁ l₂ : List α),
(l₁ ++ l₂).sublists = do
let x ← l₂.sublists
List.map (fun x_1 => x_1 ++ x) l₁.sublists | null | true |
BitVec.divSubtractShift.match_1 | Init.Data.BitVec.Bitblast | {w : ℕ} →
(motive : BitVec.DivModArgs w → Sort u_1) →
(args : BitVec.DivModArgs w) → ((n d : BitVec w) → motive { n := n, d := d }) → motive args | null | false |
_private.Init.Data.List.Perm.0.List.foldl.match_1.splitter | Init.Data.List.Perm | {α : Type u_3} →
{β : Type u_1} →
(motive : α → List β → Sort u_2) →
(x : α) →
(x_1 : List β) → ((a : α) → motive a []) → ((a : α) → (b : β) → (l : List β) → motive a (b :: l)) → motive x x_1 | null | true |
_private.Mathlib.Combinatorics.SetFamily.Shatter.0.Finset.Shatters.nonempty.match_1_1 | Mathlib.Combinatorics.SetFamily.Shatter | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} (motive : (∃ u ∈ 𝒜, s ∩ u = s) → Prop)
(x : ∃ u ∈ 𝒜, s ∩ u = s), (∀ (t : Finset α) (ht : t ∈ 𝒜) (right : s ∩ t = s), motive ⋯) → motive x | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt32.reduceMul._regBuiltin.UInt32.reduceMul.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2393314560._hygCtx._hyg.67 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
CategoryTheory.Functor.HomObj.id_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F : CategoryTheory.Functor C D} (A : CategoryTheory.Functor C (Type w)) (X : C) (x : A.obj X),
(CategoryTheory.Functor.HomObj.id A).app X x = CategoryTheory.CategoryStruct.id (F.obj X) | null | true |
Matrix.blockDiagonal'_injective | Mathlib.Data.Matrix.Block | ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_11} [inst : Zero α] [inst_1 : DecidableEq o],
Function.Injective Matrix.blockDiagonal' | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.FiveWheelLike.0.SimpleGraph.IsFiveWheelLike.minDegree_le_of_cliqueFree_fiveWheelLikeFree_succ._proof_1_11 | Mathlib.Combinatorics.SimpleGraph.FiveWheelLike | ∀ {α : Type u_1} {G : SimpleGraph α} {r k : ℕ} {v w₁ w₂ : α} {s t : Finset α} [inst : DecidableEq α],
G.IsFiveWheelLike r k v w₁ w₂ s t →
({v} ∪ ({w₁} ∪ ({w₂} ∪ (s ∪ t)))).card + k = 2 * r + 3 →
¬k = 0 →
3 ≤ ({v} ∪ ({w₁} ∪ ({w₂} ∪ (s ∪ t)))).card →
({v} ∪ ({w₁} ∪ ({w₂} ∪ (s ∪ t)))).card - ... | null | false |
Std.DTreeMap.Internal.Unit.RioSliceData.casesOn | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Unit.RioSliceData α → Sort u_1} →
(t : Std.DTreeMap.Internal.Unit.RioSliceData α) →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => Unit) →
(range : Std.Rio α) → motive { treeMap := treeMap, range := range }) →
m... | null | false |
_private.Batteries.Data.BinaryHeap.WF.0.Batteries.BinaryHeap.WF.Below.swap._proof_1_8 | Batteries.Data.BinaryHeap.WF | ∀ {α : Type u_1} {sz : ℕ} [inst : Ord α] {a : Vector α sz} {i j : Fin sz},
Batteries.BinaryHeap.WF.Below✝ a ↑i → i < j → Batteries.BinaryHeap.WF.Below✝ (a.swap ↑i ↑j ⋯ ⋯) ↑j | null | false |
ArchimedeanClass.instFieldFiniteResidueField._proof_58 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K],
Nontrivial (ArchimedeanClass.FiniteResidueField K) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.