name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
StrictAnti.wellFoundedLT | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} [WellFoundedGT β],
StrictAnti f → WellFoundedLT α | null | true |
Filter.tendsto_atTop_mono' | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] (l : Filter α) ⦃f₁ f₂ : α → β⦄,
f₁ ≤ᶠ[l] f₂ → Filter.Tendsto f₁ l Filter.atTop → Filter.Tendsto f₂ l Filter.atTop | null | true |
Lean.Meta.Tactic.Cbv.CbvSimprocOLeanEntry.keys._default | Lean.Meta.Tactic.Cbv.CbvSimproc | Array Lean.Meta.DiscrTree.Key | null | false |
segment_eq_image' | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [AddRightMono 𝕜] [inst_3 : AddCommGroup E]
[inst_4 : Module 𝕜 E] (x y : E), segment 𝕜 x y = (fun θ => x + θ • (y - x)) '' Set.Icc 0 1 | null | true |
Bool.le_true._simp_1 | Init.Data.Bool | ∀ (x : Bool), (x ≤ true) = True | null | false |
CategoryTheory.Limits.ker._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] {f g : CategoryTheory.Arrow C} (u : f ⟶ g),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f.... | null | false |
Array.mem_mapFinIdx | Init.Data.Array.MapIdx | ∀ {β : Type u_1} {α : Type u_2} {b : β} {xs : Array α} {f : (i : ℕ) → α → i < xs.size → β},
b ∈ xs.mapFinIdx f ↔ ∃ i, ∃ (h : i < xs.size), f i xs[i] h = b | null | true |
SignType.castHom._proof_3 | Mathlib.Data.Sign.Basic | ∀ {α : Type u_1} [inst : MulZeroOneClass α] [inst_1 : HasDistribNeg α], ↑1 = ↑1 | null | false |
HomotopyCategory.instIsCompatibleWithShiftHomologicalComplexIntUpHomotopic | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C],
(homotopic C (ComplexShape.up ℤ)).IsCompatibleWithShift ℤ | null | true |
CoheytingAlgebra.noConfusionType | Mathlib.Order.Heyting.Basic | Sort u → {α : Type u_4} → CoheytingAlgebra α → {α' : Type u_4} → CoheytingAlgebra α' → Sort u | null | false |
_private.Lean.Meta.Tactic.Grind.0.Lean.initFn._@.Lean.Meta.Tactic.Grind.2205948307._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind | IO Unit | null | false |
Finset.prod_filter | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : CommMonoid M] (p : ι → Prop) [inst_1 : DecidablePred p]
(f : ι → M), ∏ a ∈ s with p a, f a = ∏ a ∈ s, if p a then f a else 1 | null | true |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isNoncomputable.match_1 | Lean.Elab.DeclModifiers | (motive : Lean.Elab.ComputeKind → Sort u_1) →
(x : Lean.Elab.ComputeKind) →
(Unit → motive Lean.Elab.ComputeKind.noncomputable) → ((x : Lean.Elab.ComputeKind) → motive x) → motive x | null | false |
Equiv.subtypePiEquivPi._proof_2 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : α → Sort u_2} {p : (a : α) → β a → Prop},
Function.RightInverse (fun f => ⟨fun a => ↑(f a), ⋯⟩) fun f a => ⟨↑f a, ⋯⟩ | null | false |
Multiset.zero_disjoint | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} (l : Multiset α), Disjoint 0 l | null | true |
CategoryTheory.CommGrpObj | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] → [CategoryTheory.BraidedCategory C] → C → Type v | Abbreviation for an unbundled commutative group object. It is a group object that is a
commutative monoid object. | true |
_private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalFail._regBuiltin._private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalFail_1 | Lean.Elab.Tactic.Grind.BuiltinTactic | IO Unit | null | false |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.alphaEq._sparseCasesOn_4 | Lean.Meta.Sym.AlphaShareCommon | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t | null | false |
Fin.univ_image_get | Mathlib.Data.Fintype.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), Finset.image l.get Finset.univ = l.toFinset | null | true |
_private.Lean.Linter.Util.0.Lean.Linter.collectMacroExpansions?.go.match_4 | Lean.Linter.Util | (motive : List (List Lean.Elab.MacroExpansionInfo) → Sort u_1) →
(results : List (List Lean.Elab.MacroExpansionInfo)) →
((results : List Lean.Elab.MacroExpansionInfo) →
(tail : List (List Lean.Elab.MacroExpansionInfo)) → motive (results :: tail)) →
((x : List (List Lean.Elab.MacroExpansionInfo)) → m... | null | false |
Std.DTreeMap.instUnion | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Union (Std.DTreeMap α β cmp) | null | true |
AddSubsemigroup.equivOp_apply_coe | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] (H : AddSubsemigroup M) (a : ↥H), ↑(H.equivOp a) = AddOpposite.op ↑a | null | true |
Polynomial.UniversalCoprimeFactorizationRing.isCoprime_factor₁_factor₂ | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
IsCoprime ↑(Polynomial.UniversalCoprimeFactorizationRing.factor₁ m k hn p)
↑(Polynomial.UniversalCoprimeFactorizationRing.factor₂ m k hn p) | null | true |
MeasureTheory.Measure.measure_univ_pos._simp_1 | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (0 < μ Set.univ) = (μ ≠ 0) | null | false |
AddCircle.measurableEquivIoc.congr_simp | Mathlib.MeasureTheory.Integral.IntervalIntegral.Periodic | ∀ (T : ℝ) [hT : Fact (0 < T)] (a : ℝ), AddCircle.measurableEquivIoc T a = AddCircle.measurableEquivIoc T a | null | true |
ComplexShape.notMem_range_embeddingUpIntLE_iff | Mathlib.Algebra.Homology.Embedding.Basic | ∀ (p n : ℤ), (∀ (i : ℕ), (ComplexShape.embeddingUpIntLE p).f i ≠ n) ↔ p < n | null | true |
MonotoneOn.map_sSup_of_continuousWithinAt | Mathlib.Topology.Order.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[inst_3 : CompleteLinearOrder β] [inst_4 : TopologicalSpace β] [OrderClosedTopology β] {f : α → β} {s : Set α},
ContinuousWithinAt f s (sSup s) → MonotoneOn f s → f ⊥ = ⊥ → f (sSup s) = sSup (f '' s) | A monotone function `f` sending `bot` to `bot` and continuous at the supremum of a set sends
this supremum to the supremum of the image of this set. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int32.reduceLE._regBuiltin.Int32.reduceLE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.2667021113._hygCtx._hyg.190 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
PMF.filter_apply_eq_zero_iff | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} {p : PMF α} {s : Set α} (h : ∃ a ∈ s, a ∈ p.support) (a : α),
(p.filter s h) a = 0 ↔ a ∉ s ∨ a ∉ p.support | null | true |
CliffordAlgebra.EvenHom._sizeOf_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
{inst : CommRing R} →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} →
{Q : QuadraticForm R M} →
{A : Type u_3} →
{inst_3 : Ring A} →
{inst_4 : Algebra R A} → [SizeOf R] → [SizeOf M] → [SizeOf A] → CliffordAlgeb... | null | false |
_private.LeanSearchClient.LoogleSyntax.0.LeanSearchClient.getLoogleQueryJson.match_4 | LeanSearchClient.LoogleSyntax | (motive : Except String (Array Lean.Json) → Sort u_1) →
(x : Except String (Array Lean.Json)) →
((arr : Array Lean.Json) → motive (Except.ok arr)) → ((e : String) → motive (Except.error e)) → motive x | null | false |
CoalgHomClass | Mathlib.RingTheory.Coalgebra.Hom | (F : Type u_1) →
(R : outParam (Type u_2)) →
(A : outParam (Type u_3)) →
(B : outParam (Type u_4)) →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid A] →
[inst_2 : Module R A] →
[inst_3 : AddCommMonoid B] →
[inst_4 : Module R B] → [CoalgebraStruc... | `CoalgHomClass F R A B` asserts `F` is a type of bundled coalgebra homomorphisms
from `A` to `B`. | true |
BinaryTree.numLeaves.eq_def | Mathlib.Data.Tree.Basic | ∀ {α : Type u} (x : BinaryTree α),
x.numLeaves =
match x with
| BinaryTree.nil => 1
| BinaryTree.node value a b => a.numLeaves + b.numLeaves | null | true |
Finsupp.lcoeFun._proof_1 | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] (x y : α →₀ M), ⇑(x + y) = ⇑x + ⇑y | null | false |
_private.Lean.Environment.0.Lean.Environment.asyncConstsMap._default | Lean.Environment | Lean.VisibilityMap✝ Lean.AsyncConsts✝ | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite.0.SimpleGraph.completeEquipartiteGraph_succ_isContained_iff._simp_1_15 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {V : Type u} (G : SimpleGraph V) {s t : Set V}, G.IsCompleteBetween s t = G.IsCompleteBetween t s | null | false |
Polynomial.IsMonicOfDegree.of_mul_left | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Semiring R] {p q : Polynomial R} {m n : ℕ},
p.IsMonicOfDegree m → (p * q).IsMonicOfDegree (m + n) → q.IsMonicOfDegree n | null | true |
_private.Mathlib.Order.Heyting.Hom.0.OrderIsoClass.toHeytingHomClass._simp_1 | Mathlib.Order.Heyting.Hom | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] [inst_2 : EquivLike F α β]
[OrderIsoClass F α β] (f : F) {a : α} {b : β}, (b ≤ f a) = (EquivLike.inv f b ≤ a) | null | false |
CategoryTheory.PreGaloisCategory.instPreservesColimitsOfShapeActionFintypeCatAutFunctorSingleObjFunctorToActionOfFinite | Mathlib.CategoryTheory.Galois.Action | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (F : CategoryTheory.Functor C FintypeCat)
[inst_1 : CategoryTheory.GaloisCategory C] [CategoryTheory.PreGaloisCategory.FiberFunctor F] (G : Type u_2)
[inst_3 : Group G] [Finite G],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.SingleO... | null | true |
CStarMatrix.toCLM_apply_single_apply | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} [inst : Fintype m] [inst_1 : NonUnitalCStarAlgebra A]
[inst_2 : DecidableEq m] {M : CStarMatrix m n A} {i : m} {j : n} (a : A),
(CStarMatrix.toCLM M) ((WithCStarModule.equiv A (m → A)).symm (Pi.single i a)) j = a * M i j | null | true |
NonUnitalSubalgebra.toNonUnitalSemiring | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] → [inst_2 : Module R A] → (S : NonUnitalSubalgebra R A) → NonUnitalSemiring ↥S | null | true |
_private.Lean.MetavarContext.0.Lean.DependsOn.dep.visit | Lean.MetavarContext | (Lean.FVarId → Bool) → (Lean.MVarId → Bool) → Lean.Expr → Lean.DependsOn.M✝ Bool | null | true |
OrderHom.uliftLeftMap | Mathlib.Order.Hom.Basic | {α : Type u_2} → {β : Type u_3} → [inst : Preorder α] → [inst_1 : Preorder β] → (α →o β) → ULift.{u_8, u_2} α →o β | Lift an order homomorphism `f : α →o β` to an order homomorphism `ULift α →o β` in a
higher universe. | true |
Std.not_lt_of_ge | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α] [Std.LawfulOrderLT α] {a b : α}, a ≤ b → ¬b < a | null | true |
ULift.instLinearOrder._proof_2 | Mathlib.Order.Lattice | ∀ {α : Type u_2} [inst : LinearOrder α] {x y : ULift.{u_1, u_2} α}, x.down < y.down ↔ x < y | null | false |
Metric.closedBall_subset_closedBall | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε₁ ε₂ : ℝ},
ε₁ ≤ ε₂ → Metric.closedBall x ε₁ ⊆ Metric.closedBall x ε₂ | null | true |
CategoryTheory.MonoidalCategory.associator_naturality_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} {𝒞 : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.MonoidalCategory C] {X₁ X₂ X₃ Y₁ Y₂ Y₃ : C}
(f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj Y₁ (CategoryTheory.MonoidalCategoryStruct.tensorObj Y₂ Y₃) ⟶ Z),
CategoryTheory.Catego... | Naturality of the associator isomorphism: `(f₁ ⊗ₘ f₂) ⊗ₘ f₃ ≃ f₁ ⊗ₘ (f₂ ⊗ₘ f₃)` | true |
ContinuousLinearMap.uniformContinuous | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {E₁ : Type u_9}
{E₂ : Type u_10} [inst_2 : UniformSpace E₁] [inst_3 : UniformSpace E₂] [inst_4 : AddCommGroup E₁]
[inst_5 : AddCommGroup E₂] [inst_6 : Module R₁ E₁] [inst_7 : Module R₂ E₂] [IsUniformAddGroup E₁]
[IsUni... | null | true |
Array.extract_size_left | Init.Data.Array.Extract | ∀ {α : Type u_1} {j : ℕ} {as : Array α}, as.extract as.size j = #[] | null | true |
_private.Init.Data.Array.Lemmas.0.Array.append_eq_singleton_iff._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a b : List α} {x : α}, (a ++ b = [x]) = (a = [] ∧ b = [x] ∨ a = [x] ∧ b = []) | null | false |
CategoryTheory.Limits.LimitBicone.mk.inj | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type uC} {inst : CategoryTheory.Category.{uC', uC} C}
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} {F : J → C} {bicone : CategoryTheory.Limits.Bicone F}
{isBilimit : bicone.IsBilimit} {bicone_1 : CategoryTheory.Limits.Bicone F} {isBilimit_1 : bicone_1.IsBilimit},
{ bicone := bicone, isB... | null | true |
DFinsupp.small | Mathlib.Data.DFinsupp.Small | ∀ {ι : Type u} {π : ι → Type v} [inst : (i : ι) → Zero (π i)] [Small.{w, u} ι] [∀ (i : ι), Small.{w, v} (π i)],
Small.{w, max v u} (DFinsupp π) | null | true |
LinearEquiv.curry._proof_2 | Mathlib.Algebra.Module.Equiv.Basic | ∀ (R : Type u_4) (M : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (V : Type u_1)
(V₂ : Type u_2) (x : R) (x_1 : V × V₂ → M),
(Equiv.curry V V₂ M).toFun (x • x_1) = (Equiv.curry V V₂ M).toFun (x • x_1) | null | false |
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valued.integer.mem_iff._simp_1_2 | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {r₁ r₂ : NNReal}, (r₁ ≤ r₂) = (↑r₁ ≤ ↑r₂) | null | false |
DirichletCharacter.LFunction_ne_zero_of_one_le_re | Mathlib.NumberTheory.LSeries.Nonvanishing | ∀ {N : ℕ} (χ : DirichletCharacter ℂ N) [inst : NeZero N] ⦃s : ℂ⦄,
χ ≠ 1 ∨ s ≠ 1 → 1 ≤ s.re → DirichletCharacter.LFunction χ s ≠ 0 | If `χ` is a Dirichlet character, then `L(χ, s)` does not vanish for `s.re ≥ 1`
except when `χ` is trivial and `s = 1` (then `L(χ, s)` has a simple pole at `s = 1`). | true |
_private.Lean.Environment.0.Lean.ImportedModule.mk.injEq | Lean.Environment | ∀ (toEffectiveImport : Lean.EffectiveImport) (parts : Array (Lean.ModuleData × Lean.CompactedRegion))
(irData? : Option (Lean.ModuleData × Lean.CompactedRegion)) (needsIRTrans : Bool)
(toEffectiveImport_1 : Lean.EffectiveImport) (parts_1 : Array (Lean.ModuleData × Lean.CompactedRegion))
(irData?_1 : Option (Lean.... | null | true |
Std.Rxo.Iterator.mk.sizeOf_spec | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : SizeOf α] (next : Option α) (upperBound : α),
sizeOf { next := next, upperBound := upperBound } = 1 + sizeOf next + sizeOf upperBound | null | true |
SSet.N.cast | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | {X : SSet} → (s : X.N) → {d : ℕ} → s.dim = d → X.N | When `s : X.N` is such that `s.dim = d`, this is a term
that is equal to `s`, but whose dimension if definitionally equal to `d`. | true |
normalClosure_of_stabilizer_eq_top | Mathlib.GroupTheory.GroupAction.Jordan | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α],
2 < ENat.card α →
MulAction.IsMultiplyPretransitive G α 2 → ∀ {a : α}, Subgroup.normalClosure ↑(MulAction.stabilizer G a) = ⊤ | In a 2-transitive action, the normal closure of stabilizers is the full group. | true |
_private.Aesop.Util.Tactic.Ext.0.Aesop.straightLineExt.go._sparseCasesOn_5 | Aesop.Util.Tactic.Ext | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Prod.instSemiring._proof_11 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
Std.Internal.List.isEmpty_filter_containsKey_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((a : α) × β a)},
l₁.isEmpty = true → (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁).isEmpty = true | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Integrals.Basic.0.integral_cos_sq._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Subgroup.exists_smul_eq | Mathlib.GroupTheory.SchurZassenhaus | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [inst_1 : IsMulCommutative ↥H] [inst_2 : H.FiniteIndex]
[inst_3 : H.Normal], (Nat.card ↥H).Coprime H.index → ∀ (α β : H.QuotientDiff), ∃ h, h • α = β | null | true |
CategoryTheory.PreZeroHypercover.sectionsSaturateEquiv_apply_coe | Mathlib.CategoryTheory.Sites.Hypercover.Saturate | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.Functor Cᵒᵖ (Type u_3)) (s : (E.saturate.multicospanIndex F).sections)
(i : E.saturate.multicospanShape.L), ↑((E.sectionsSaturateEquiv F) s) i = s.val i | null | true |
NonUnitalNonAssocCommRing.mul_comm | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [self : NonUnitalNonAssocCommRing α] (a b : α), a * b = b * a | Multiplication is commutative in a commutative multiplicative magma. | true |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.sc._proof_3 | Mathlib.Algebra.Homology.ExactSequence | ∀ {n : ℕ} (i : ℕ), ¬i + 1 + 1 = i + 2 → False | null | false |
CategoryTheory.PreGaloisCategory.endEquivAutGalois | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
(F : CategoryTheory.Functor C FintypeCat) →
[CategoryTheory.PreGaloisCategory.FiberFunctor F] →
CategoryTheory.End F ≃ CategoryTheory.PreGaloisCategory.AutGalois F | The equivalence between endomorphisms of `F` and the limit over the automorphism groups
of all Galois objects. | true |
Relation.SymmGen | Mathlib.Logic.Relation | {α : Sort u_1} → (α → α → Prop) → α → α → Prop | `SymmGen r`: symmetric closure of `r`. This is also the comparability relation, such
that `SymmGen r a b` means that either `r a b` or `r b a` (see `Mathlib.Order.Comparable`). | true |
SSet.Truncated.StrictSegal.spineToSimplex_interval | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ} {X : SSet.Truncated (n + 1)} (sx : X.StrictSegal) (m : ℕ) (h : m ≤ n + 1) (f : X.Path m) (j l : ℕ)
(hjl : j + l ≤ m),
(CategoryTheory.ConcreteCategory.hom
(X.map (SimplexCategory.Truncated.Hom.tr (SimplexCategory.subinterval j l hjl) ⋯ h).op))
(sx.spineToSimplex m h f) =
sx.spineToSimple... | null | true |
NonUnitalAlgHom.mk.inj | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} {inst : Monoid R} {inst_1 : Monoid S} {φ : R →* S} {A : Type v} {B : Type w}
{inst_2 : NonUnitalNonAssocSemiring A} {inst_3 : DistribMulAction R A} {inst_4 : NonUnitalNonAssocSemiring B}
{inst_5 : DistribMulAction S B} {toDistribMulActionHom : A →ₑ+[φ] B}
{map_mul' :
∀ (x y : A), ... | null | true |
LowerSemicontinuousWithinAt | Mathlib.Topology.Semicontinuity.Defs | {α : Type u_1} → {β : Type u_2} → [TopologicalSpace α] → [Preorder β] → (α → β) → Set α → α → Prop | A real function `f` is lower semicontinuous at `x` within a set `s` if, for any `ε > 0`, for all
`x'` close enough to `x` in `s`, then `f x'` is at least `f x - ε`. We formulate this in a general
preordered space, using an arbitrary `y < f x` instead of `f x - ε`. | true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.deriveInductionStructural.match_24 | Lean.Meta.Tactic.FunInd | (motive : Lean.Expr × Array Bool × Array ℕ → Sort u_1) →
(x : Lean.Expr × Array Bool × Array ℕ) →
((e' : Lean.Expr) → (paramMask : Array Bool) → (motiveArities : Array ℕ) → motive (e', paramMask, motiveArities)) →
motive x | null | false |
Std.ExtTreeSet.getD_inter_of_not_mem_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k fallback : α},
k ∉ t₁ → (t₁ ∩ t₂).getD k fallback = fallback | null | true |
Field.Emb.Cardinal.strictMono_leastExt | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E],
StrictMono (Field.Emb.Cardinal.leastExt F E) | null | true |
List.mem_foldr_permutationsAux2 | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {t : α} {ts : List α} {r L : List (List α)} {l' : List α},
l' ∈ List.foldr (fun y r => (List.permutationsAux2 t ts r y id).2) r L ↔
l' ∈ r ∨ ∃ l₁ l₂, l₁ ++ l₂ ∈ L ∧ l₂ ≠ [] ∧ l' = l₁ ++ t :: l₂ ++ ts | null | true |
RelEmbedding._sizeOf_1 | Mathlib.Order.RelIso.Basic | {α : Type u_5} →
{β : Type u_6} →
{r : α → α → Prop} →
{s : β → β → Prop} →
[SizeOf α] → [SizeOf β] → [(a a_1 : α) → SizeOf (r a a_1)] → [(a a_1 : β) → SizeOf (s a a_1)] → r ↪r s → ℕ | null | false |
Configuration.ProjectivePlane.ctorIdx | Mathlib.Combinatorics.Configuration | {P : Type u_1} → {L : Type u_2} → {inst : Membership P L} → Configuration.ProjectivePlane P L → ℕ | null | false |
_private.Mathlib.Computability.Primrec.Basic.0.Primrec.nat_div._simp_1_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Lean.Parser.ParserCacheEntry.mk._flat_ctor | Lean.Parser.Types | Lean.Syntax → ℕ → String.Pos.Raw → Option Lean.Parser.Error → Lean.Parser.ParserCacheEntry | null | false |
Matrix.isRepresentation._proof_4 | Mathlib.LinearAlgebra.Matrix.Charpoly.LinearMap | ∀ {ι : Type u_3} [inst : Fintype ι] {M : Type u_1} [inst_1 : AddCommGroup M] (R : Type u_2) [inst_2 : CommRing R]
[inst_3 : Module R M] (b : ι → M) [inst_4 : DecidableEq ι], ∃ f, Matrix.Represents b 0 f | null | false |
CategoryTheory.sum.inlCompAssociator_hom_app | Mathlib.CategoryTheory.Sums.Associator | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(E : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (X : C ⊕ D),
(CategoryTheory.sum.inlCompAssociator C D E).hom.app X =
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Sum.i... | null | true |
StandardEtalePair.Ring | Mathlib.RingTheory.Etale.StandardEtale | {R : Type u_1} → [inst : CommRing R] → StandardEtalePair R → Type u_1 | The standard etale algebra `R[X][Y]/⟨f, Yg-1⟩` associated to a `StandardEtalePair R`.
Also see
`equivPolynomialQuotient : P.Ring ≃ R[X][Y]/⟨f, Yg-1⟩`
`equivAwayAdjoinRoot : P.Ring ≃ (R[X]/f)[1/g]`
`equivAwayQuotient : P.Ring ≃ R[X][1/g]/f`
`equivMvPolynomialQuotient : P.Ring ≃ R[X, Y]/⟨f, Yg-1⟩` | true |
Aesop.RuleBuilderInput._sizeOf_1 | Aesop.Builder.Basic | Aesop.RuleBuilderInput → ℕ | null | false |
Std.DHashMap.Raw.instMembershipOfBEqOfHashable | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [BEq α] → [Hashable α] → Membership α (Std.DHashMap.Raw α β) | null | true |
_private.Lean.Util.CollectLevelParams.0.Lean.CollectLevelParams.State.getUnusedLevelParam.loop | Lean.Util.CollectLevelParams | Lean.CollectLevelParams.State → Lean.Name → ℕ → Lean.Level | null | true |
Int8.le_of_lt | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, a < b → a ≤ b | null | true |
CategoryTheory.Endofunctor.algebraPreadditive_homGroup_nsmul_f | Mathlib.CategoryTheory.Preadditive.EndoFunctor | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C]
(F : CategoryTheory.Functor C C) [inst_2 : F.Additive] (A₁ A₂ : CategoryTheory.Endofunctor.Algebra F) (n : ℕ)
(α : A₁ ⟶ A₂), (n • α).f = n • α.f | null | true |
IndexedPartition.piecewise_apply | Mathlib.Data.Setoid.Partition | ∀ {ι : Type u_1} {α : Type u_2} {s : ι → Set α} (hs : IndexedPartition s) {β : Type u_3} {f : ι → α → β} (x : α),
hs.piecewise f x = f (hs.index x) x | null | true |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.VectorField.mlieBracketWithin_smul_left._abel_1_1 | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {H : Type u_3} [inst_1 : TopologicalSpace H] {E : Type u_1}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {x : M} {V W : (x : M) → Ta... | null | false |
_private.Init.Data.Array.Range.0.Array.range'_concat._simp_1_1 | Init.Data.Array.Range | ∀ {s m n step : ℕ}, Array.range' s (m + n) step = Array.range' s m step ++ Array.range' (s + step * m) n step | null | false |
Module.Finite.instLinearMapIdSubtypeMemSubmoduleOfIsSemisimpleModule | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {m : Submodule R M}
(R₀ : Type u_6) (P : Type u_7) [inst_3 : Semiring R₀] [inst_4 : AddCommMonoid P] [inst_5 : Module R P]
[inst_6 : Module R₀ P] [inst_7 : SMulCommClass R R₀ P] [Module.Finite R₀ (M →ₗ[R] P)] [IsSemisimp... | null | true |
CategoryTheory.obj_η_app_assoc | Mathlib.CategoryTheory.Monoidal.End | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} M]
[inst_2 : CategoryTheory.MonoidalCategory M] (F : CategoryTheory.Functor M (CategoryTheory.Functor C C)) (n : M)
(X : C) [inst_3 : F.Monoidal] {Z : C}
(h : (F.obj n).obj ((CategoryTheory.Monoida... | null | true |
fourier_coe_apply' | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ} {n : ℤ} {x : ℝ}, ↑(AddCircle.toCircle (n • ↑x)) = Complex.exp (2 * ↑Real.pi * Complex.I * ↑n * ↑x / ↑T) | null | true |
WeierstrassCurve.Jacobian.Point.neg_point | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} (P : W.Point), (-P).point = W.negMap P.point | null | true |
_private.Mathlib.Data.Finset.Sum.0.Finset.disjSum_eq_empty._simp_1_1 | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ | null | false |
OrderType.card_zero | Mathlib.Order.Types.Arithmetic | OrderType.card 0 = 0 | null | true |
Std.ExtHashSet.size_left_le_size_union | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], m₁.size ≤ (m₁ ∪ m₂).size | null | true |
CategoryTheory.FreeMonoidalCategory.normalizeIsoApp' | Mathlib.CategoryTheory.Monoidal.Free.Coherence | (C : Type u) →
(X : CategoryTheory.FreeMonoidalCategory C) →
(n : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.FreeMonoidalCategory.inclusionObj n) X ≅
CategoryTheory.FreeMonoidalCategory.inclusionObj (X.normalizeObj n) | Almost non-definitionally equal to `normalizeIsoApp`, but has a better definitional property
in the proof of `normalize_naturality`. | true |
FinEnum.Subtype.finEnum._proof_1 | Mathlib.Data.FinEnum | ∀ {α : Type u_1} [inst : FinEnum α] (p : α → Prop) [inst_1 : DecidablePred p] (x : { x // p x }),
x ∈ List.filterMap (fun x => if h : p x then some ⟨x, h⟩ else none) (FinEnum.toList α) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.