name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Sym.InstantiateS.0.Lean.Meta.Sym.instantiateRevBetaS'.visit.match_1 | Lean.Meta.Sym.InstantiateS | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((a : Lean.Literal) → e = Lean.Expr.lit a → motive (Lean.Expr.lit a)) →
((mvarId : Lean.MVarId) → e = Lean.Expr.mvar mvarId → motive (Lean.Expr.mvar mvarId)) →
((fvarId : Lean.FVarId) → e = Lean.Expr.fvar fvarId → motive (Lean.Expr.fvar fvarId)) →
... | null | false |
Lean.Meta.Sym.Simp.Context | Lean.Meta.Sym.Simp.SimpM | Type | Read-only context for the simplifier. | true |
BitVec.getLsb | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → Fin w → Bool | Returns the `i`th least significant bit.
| true |
CategoryTheory.Pseudofunctor.ObjectProperty.noConfusionType | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | Sort u_1 →
{B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat} →
F.ObjectProperty →
{B' : Type u} →
[inst' : CategoryTheory.Bicategory B'] →
{F' : CategoryTheory.Pseudofunctor B' CategoryTheory.Cat} → F'.Ob... | null | false |
SimpleGraph.Hom.map | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} →
{W : Type u_2} → (f : V → W) → (G : SimpleGraph V) → (∀ {u v : V}, G.Adj u v → f u ≠ f v) → G →g SimpleGraph.map f G | A function `f` that is injective on adjacent vertices in a graph `G`
(equivalently `f` is a valid `W`-coloring of `G`, or `G ≤ comap ⊤ f`)
is a homomorphism from `G` to the mapped graph. | true |
PreTilt.instCommRing._proof_27 | Mathlib.RingTheory.Perfection | ∀ (O : Type u_1) [inst : CommRing O] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p]
(a b c : PreTilt O p), (a + b) * c = a * c + b * c | null | false |
Array.ne_push_self._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α}, (xs = xs.push a) = False | null | false |
Set.add_univ | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {s : Set α}, s.Nonempty → s + Set.univ = Set.univ | null | true |
ContinuousMap.compAddMonoidHom'._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_2}
[inst_2 : TopologicalSpace γ] [inst_3 : AddZeroClass γ] (g : C(α, β)), ContinuousMap.comp 0 g = 0 | null | false |
Std.Tactic.BVDecide.BoolExpr.toString._unsafe_rec | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | {α : Type} → [ToString α] → Std.Tactic.BVDecide.BoolExpr α → String | null | false |
Mathlib.Tactic.Bound._aux_Mathlib_Tactic_Bound_Attribute___macroRules_Mathlib_Tactic_Bound_attrBound_forward_1 | Mathlib.Tactic.Bound.Attribute | Lean.Macro | Attribute for `forward` rules for the `bound` tactic.
`@[bound_forward]` lemmas should produce inequalities given other hypotheses that might be in the
context. A typical example is exposing an inequality field of a structure, such as
`HasPowerSeriesOnBall.r_pos`. | false |
Lean.Doc.Block.dl | Lean.DocString.Types | {i : Type u} → {b : Type v} → Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Lean.Doc.Block i b | A description list that associates explanatory text with shorter items.
| true |
Set.mem_mulAntidiagonal | Mathlib.Data.Set.MulAntidiagonal | ∀ {α : Type u_1} [inst : Mul α] {s t : Set α} {a : α} {x : α × α},
x ∈ s.mulAntidiagonal t a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 * x.2 = a | null | true |
Int.Linear.Poly.coeff_k.eq_1 | Init.Data.Int.Linear | ∀ (p : Int.Linear.Poly) (x : Int.Linear.Var),
p.coeff_k x = Int.Linear.Poly.rec (fun x => 0) (fun a y x_1 ih => Bool.rec ih a (Nat.beq x y)) p | null | true |
ENat.coe_ne_top._simp_2 | Mathlib.Tactic.ENatToNat | ∀ (a : ℕ), (↑a = ⊤) = False | null | false |
CategoryTheory.Discrete.productEquiv._proof_15 | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_1} {K : Type u_2} {X Y : CategoryTheory.Discrete J × CategoryTheory.Discrete K} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(({
obj := fun x =>
match x with
| (x, y) => { as := (x.as, y.as) },
map := fun {X Y} x =>
... | null | false |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.removeNegAssignment.eq_4 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned.removeNegAssignment =
Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned | null | true |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.ExistsContDiffBumpBase.y_eq_zero_of_notMem_ball._simp_1_4 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | null | false |
Std.ExtTreeMap.ne_empty_of_erase_ne_empty | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
t.erase k ≠ ∅ → t ≠ ∅ | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Char.0.String.Slice.startsWith_char_iff_exists_append._simp_1_2 | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ {α : Type u_1} {xs : List α} {a : α}, (xs.head? = some a) = ∃ ys, xs = a :: ys | null | false |
CategoryTheory.MonoidalCategory.ofTensorHom._auto_9 | Mathlib.CategoryTheory.Monoidal.Category | Lean.Syntax | null | false |
CategoryTheory.Sum.associativityFunctorEquivNaturalityFunctorIso_hom_app_snd_fst | Mathlib.CategoryTheory.Sums.Products | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {A' : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} A'] {B : Type u} [inst_2 : CategoryTheory.Category.{v, u} B]
(T : Type u_3) [inst_3 : CategoryTheory.Category.{v_3, u_3} T] (X : CategoryTheory.Functor ((A ⊕ A') ⊕ T) B),
((CategoryTheory.Su... | null | true |
AddMonoid.Coprod.map._proof_4 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_3} {N : Type u_4} {M' : Type u_1} {N' : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass M'] [inst_3 : AddZeroClass N'] (f : M →+ M') (g : N →+ N') (x y : N),
(AddMonoid.Coprod.mk.comp (FreeAddMonoid.map (Sum.map ⇑f ⇑g))) (FreeAddMonoid.of (Sum.inr (x + y))) =
(Ad... | null | false |
Equiv.sumEmpty | Mathlib.Logic.Equiv.Sum | (α : Type u_9) → (β : Type u_10) → [IsEmpty β] → α ⊕ β ≃ α | Sum with `IsEmpty` is equivalent to the original type. | true |
AlgebraicGeometry.IsReduced.mk | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme},
autoParam (∀ (U : X.Opens), IsReduced ↑(X.presheaf.obj (Opposite.op U)))
AlgebraicGeometry.IsReduced.component_reduced._autoParam →
AlgebraicGeometry.IsReduced X | null | true |
or_iff_right_iff_imp._simp_1 | Init.SimpLemmas | ∀ {a b : Prop}, (a ∨ b ↔ b) = (a → b) | null | false |
Turing.BlankRel.refl | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (l : List Γ), Turing.BlankRel l l | null | true |
_private.Lean.Meta.ExprLens.0.Lean.Core.viewBindersCoord._sparseCasesOn_2 | Lean.Meta.ExprLens | {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 |
HomologicalComplex.mapBifunctor₂₃.D₂ | Mathlib.Algebra.Homology.BifunctorAssociator | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₂₃ : Type u_4} →
{C₃ : Type u_5} →
{C₄ : Type u_6} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] →
[inst_... | The second differential on `mapBifunctor K₁ (mapBifunctor K₂ K₃ G₂₃ c₂₃) F c₄`. | true |
CategoryTheory.Limits.DiagramOfCocones.mk.inj | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} J}
{inst_1 : CategoryTheory.Category.{v_2, u_2} K} {C : Type u_3} {inst_2 : CategoryTheory.Category.{v_3, u_3} C}
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {obj : (j : J) → CategoryTheory.Limits.Cocone (F.obj j)}
{map : {... | null | true |
Functor.Comp.instPure | Mathlib.Control.Functor | {F : Type u → Type w} → {G : Type v → Type u} → [Applicative F] → [Applicative G] → Pure (Functor.Comp F G) | null | true |
Sylow.card_normalizer_modEq_card | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G] [Finite G] {p n : ℕ} [hp : Fact (Nat.Prime p)] {H : Subgroup G},
Nat.card ↥H = p ^ n → Nat.card ↥(Subgroup.normalizer ↑H) ≡ Nat.card G [MOD p ^ (n + 1)] | If `H` is a subgroup of `G` of cardinality `p ^ n`, then the cardinality of the
normalizer of `H` is congruent mod `p ^ (n + 1)` to the cardinality of `G`. | true |
_private.Mathlib.Tactic.Linter.HaveLetLinter.0.Mathlib.Linter.haveLet.initFn._@.Mathlib.Tactic.Linter.HaveLetLinter.3906617390._hygCtx._hyg.2 | Mathlib.Tactic.Linter.HaveLetLinter | IO Unit | null | false |
Lean.Meta.Grind.AC.EqCnstr.mk.inj | Lean.Meta.Tactic.Grind.AC.Types | ∀ {lhs rhs : Lean.Grind.AC.Seq} {h : Lean.Meta.Grind.AC.EqCnstrProof} {id : ℕ} {lhs_1 rhs_1 : Lean.Grind.AC.Seq}
{h_1 : Lean.Meta.Grind.AC.EqCnstrProof} {id_1 : ℕ},
{ lhs := lhs, rhs := rhs, h := h, id := id } = { lhs := lhs_1, rhs := rhs_1, h := h_1, id := id_1 } →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ h = h_1 ∧ id = id... | null | true |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDenseLp.0.MeasureTheory.SimpleFunc.memLp_approxOn._simp_1_2 | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] (a b : E), ‖a - b‖ = dist a b | null | false |
Meromorphic.MeromorphicOn.countable_compl_analyticAt | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} [SecondCountableTopology 𝕜] [CompleteSpace E],
Meromorphic f → {z | AnalyticAt 𝕜 f z}ᶜ.Countable | **Alias** of `Meromorphic.countable_compl_analyticAt`.
---
The singular set of a meromorphic function is countable.
| true |
ENNReal.HolderTriple.inv_le_inv | Mathlib.Data.ENNReal.Holder | ∀ (p q r : ENNReal) [p.HolderTriple q r], p⁻¹ ≤ r⁻¹ | null | true |
AddMonCat.limitAddMonoid._proof_3 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddMonCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddMonCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget AddMonCat))).pt), a + 0 = a | null | false |
ConvexCone.IsGenerating.top_le_span | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] {C : ConvexCone R M}, C.IsGenerating → ⊤ ≤ Submodule.span R ↑C | Top is less than or equal to the linear span of a generating convex cone. | true |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_23 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α} (hl : l ≠ []),
l.length - (l.dropLast.length + 1) + 1 ≤ [l.getLast ⋯].dropLast.length →
l.length - (l.dropLast.length + 1) < [l.getLast ⋯].dropLast.length | null | false |
CovBy.coe_fin | Mathlib.Data.Nat.SuccPred | ∀ {n : ℕ} {a b : Fin n}, a ⋖ b → ↑a ⋖ ↑b | **Alias** of the forward direction of `Fin.covBy_iff`. | true |
List.isSome_max?_of_mem | Init.Data.List.MinMax | ∀ {α : Type u_1} {l : List α} [inst : Max α] {a : α}, a ∈ l → l.max?.isSome = true | null | true |
_private.Lean.Meta.Match.AltTelescopes.0.Lean.Meta.Match.forallAltVarsTelescope.isNamedPatternProof | Lean.Meta.Match.AltTelescopes | Lean.Expr → Lean.Expr → Bool | null | true |
Lean.ReducibilityHints.ctorElim | Lean.Declaration | {motive : Lean.ReducibilityHints → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.ReducibilityHints) → ctorIdx = t.ctorIdx → Lean.ReducibilityHints.ctorElimType ctorIdx → motive t | null | false |
instSetLikeSubRootedTreeα._proof_3 | Mathlib.Order.SuccPred.Tree | ∀ (t : RootedTree) (a₁ a₂ : SubRootedTree t), (fun v => Set.Ici v.root) a₁ = (fun v => Set.Ici v.root) a₂ → a₁ = a₂ | null | false |
PadicInt.instMetricSpace._aux_20 | Mathlib.NumberTheory.Padics.PadicIntegers | (p : ℕ) → [hp : Fact (Nat.Prime p)] → Filter ℤ_[p] | null | false |
CategoryTheory.Grothendieck.map_obj_fiber | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C CategoryTheory.Cat} (α : F ⟶ G)
(X : CategoryTheory.Grothendieck F),
((CategoryTheory.Grothendieck.map α).obj X).fiber = (α.app X.base).toFunctor.obj X.fiber | null | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.«term𝒰(_,_,_)» | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | Lean.ParserDescr | null | true |
IsCentralVAdd.mk._flat_ctor | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_9} {α : Type u_10} [inst : VAdd M α] [inst_1 : VAdd Mᵃᵒᵖ α],
(∀ (m : M) (a : α), AddOpposite.op m +ᵥ a = m +ᵥ a) → IsCentralVAdd M α | null | false |
AddCon.addCommMagma | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_4} → [inst : AddCommMagma M] → (c : AddCon M) → AddCommMagma c.Quotient | The quotient of an `AddCommMagma` by an additive congruence relation is
an `AddCommMagma`. | true |
Lean.Elab.TermInfo.recOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.TermInfo → Sort u} →
(t : Lean.Elab.TermInfo) →
((toElabInfo : Lean.Elab.ElabInfo) →
(lctx : Lean.LocalContext) →
(expectedType? : Option Lean.Expr) →
(expr : Lean.Expr) →
(isBinder isDisplayableTerm : Bool) →
motive
... | null | false |
instSTWorldEST | Init.System.ST | {ε σ : Type} → STWorld σ (EST ε σ) | null | true |
CategoryTheory.Abelian.SpectralObject.iCycles_δ | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (n₀ n₁ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.Sp... | null | true |
Aesop.getGoalsToCopy | Aesop.Tree.AddRapp | Aesop.UnorderedArraySet Lean.MVarId → Aesop.GoalRef → Aesop.TreeM (Array Aesop.GoalRef) | null | true |
_private.Mathlib.RingTheory.Localization.NumDen.0.IsFractionRing.isUnit_den_zero._simp_1_2 | Mathlib.RingTheory.Localization.NumDen | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
IsLocalization.IsInteger R 0 = True | null | false |
String.Slice.Pattern.Model.PatternModel.noConfusion | Init.Data.String.Lemmas.Pattern.Basic | {P : Sort u} →
{ρ : Type} →
{pat : ρ} →
{t : String.Slice.Pattern.Model.PatternModel pat} →
{ρ' : Type} →
{pat' : ρ'} →
{t' : String.Slice.Pattern.Model.PatternModel pat'} →
ρ = ρ' → pat ≍ pat' → t ≍ t' → String.Slice.Pattern.Model.PatternModel.noConfusionType P t... | null | false |
TensorProduct.sum_tmul_basis_left_eq_zero | Mathlib.LinearAlgebra.TensorProduct.Basis | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {ι : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N] (ℬ : Module.Basis ι R M) (b : ι →₀ N),
(b.sum fun i n => ℬ i ⊗ₜ[R] n) = 0 → b = 0 | null | true |
IsAlgebraic.algebraMap | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {S : Type u_1} {A : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Ring A]
[inst_3 : Algebra R A] [inst_4 : Algebra R S] [inst_5 : Algebra S A] [IsScalarTower R S A] {a : S},
IsAlgebraic R a → IsAlgebraic R ((algebraMap S A) a) | null | true |
AdicCompletion.instNeg._proof_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_2} [inst : CommRing R] (I : Ideal R) (M : Type u_1) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : AdicCompletion I M) {m n : ℕ} (hmn : m ≤ n), (AdicCompletion.transitionMap I M hmn) ((-↑x) n) = (-↑x) m | null | false |
ISize.ofIntLE_bitVecToInt | Init.Data.SInt.Lemmas | ∀ (n : BitVec System.Platform.numBits), ISize.ofIntLE n.toInt ⋯ ⋯ = ISize.ofBitVec n | null | true |
CategoryTheory.Precoverage.ZeroHypercover.Small.casesOn | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Precoverage C} →
{S : C} →
{E : J.ZeroHypercover S} →
{motive : E.Small → Sort u_1} →
(t : E.Small) →
((exists_restrictIndex_mem : ∃ ι f, (E.restrictIndex f).presieve₀ ∈ J.coverings S) ... | null | false |
Std.DTreeMap.Raw.forM_eq_forM_keysArray | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} {m : Type w → Type w'}
[inst : Monad m] [LawfulMonad m] {f : α → m PUnit.{w + 1}}, (forM t fun a => f a.fst) = Array.forM f t.keysArray | null | true |
CategoryTheory.Limits.epi_image_of_epi | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasImage f] [E : CategoryTheory.Epi f],
CategoryTheory.Epi (CategoryTheory.Limits.image.ι f) | null | true |
Lean.Meta.getAllSimpDecls._sparseCasesOn_2 | Mathlib.Lean.Meta.Simp | {motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Nat.infinite_odd_deficient | Mathlib.NumberTheory.FactorisationProperties | {n | Odd n ∧ n.Deficient}.Infinite | null | true |
SheafOfModules.QuasicoherentData.noConfusionType | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | Sort u_1 →
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : ∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] →
[inst_2 : ∀ (X : C), C... | null | false |
CategoryTheory.ProjectivePresentation.mk.sizeOf_spec | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} [inst_1 : SizeOf C] (p : C)
[projective : CategoryTheory.Projective p] (f : p ⟶ X) [epi : CategoryTheory.Epi f],
sizeOf { p := p, projective := projective, f := f, epi := epi } =
1 + sizeOf p + sizeOf projective + sizeOf f + sizeOf epi | null | true |
_private.Lean.Meta.Sym.Util.0.Lean.Meta.Sym.foldProjs.match_1 | Lean.Meta.Sym.Util | (motive : Option Lean.StructureInfo → Sort u_1) →
(x : Option Lean.StructureInfo) →
((info : Lean.StructureInfo) → motive (some info)) → ((x : Option Lean.StructureInfo) → motive x) → motive x | null | false |
Ordinal.nfp_zero | Mathlib.SetTheory.Ordinal.FixedPoint | Ordinal.nfp 0 = id | null | true |
String.eq_empty_iff_forall_eq | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String}, s = "" ↔ ∀ (p q : s.Pos), p = q | null | true |
Std.Internal.List.getKey?_eq_getEntry? | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α},
Std.Internal.List.getKey? a l = Option.map (fun x => x.fst) (Std.Internal.List.getEntry? a l) | null | true |
Int.radical_natCast | Mathlib.RingTheory.Radical.NatInt | ∀ {n : ℕ}, UniqueFactorizationMonoid.radical ↑n = ↑(UniqueFactorizationMonoid.radical n) | null | true |
SimplexCategory.len_le_of_epi | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {x y : SimplexCategory} (f : x ⟶ y) [CategoryTheory.Epi f], y.len ≤ x.len | An epimorphism in `SimplexCategory` must decrease lengths | true |
DilationEquiv.smulTorsor._proof_3 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {𝕜 : Type u_3} {E : Type u_2} [inst : NormedDivisionRing 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module 𝕜 E]
[NormSMulClass 𝕜 E] {P : Type u_1} [inst_4 : PseudoMetricSpace P] [inst_5 : NormedAddTorsor E P] (c : P) {k : 𝕜}
(x y : E), edist (k • x +ᵥ c) (k • y +ᵥ c) = ↑‖k‖₊ * edist x y | null | false |
AlgebraicGeometry.quasiSeparatedSpace_of_isAffine | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ (X : AlgebraicGeometry.Scheme) [AlgebraicGeometry.IsAffine X], QuasiSeparatedSpace ↥X | null | true |
Sym.fill | Mathlib.Data.Sym.Basic | {α : Type u_1} → {n : ℕ} → α → (i : Fin (n + 1)) → Sym α (n - ↑i) → Sym α n | Fill a term `m : Sym α (n - i)` with `i` copies of `a` to obtain a term of `Sym α n`.
This is a convenience wrapper for `m.append (replicate i a)` that adjusts the term using
`Sym.cast`. | true |
Matrix.toLinearMap₂'Aux._proof_2 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R₁ : Type u_7} {S₁ : Type u_6} {R₂ : Type u_5} {S₂ : Type u_4} {N₂ : Type u_1} {n : Type u_2} {m : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring S₁] [inst_2 : Semiring R₂] [inst_3 : Semiring S₂] [inst_4 : AddCommMonoid N₂]
[inst_5 : Module S₁ N₂] [inst_6 : Module S₂ N₂] [SMulCommClass S₂ S₁ N₂] [inst_8 : Fin... | null | false |
CochainComplex.HomComplex.Cocycle.toSingleMk_add._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X : C}
{K : CochainComplex C ℤ} {p : ℤ} (f g : K.X p ⟶ X) (p' : ℤ),
CategoryTheory.CategoryStruct.comp (K.d p' p) f = 0 →
CategoryTheory.CategoryStruct.comp (K.d p' p) g = 0 → CategoryTheory.CategoryStruct.co... | null | false |
FreeLieAlgebra.Rel.lie_self | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] (a : FreeNonUnitalNonAssocAlgebra R X), FreeLieAlgebra.Rel R X (a * a) 0 | null | true |
Multiset.right_mem_Ioc | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, b ∈ Multiset.Ioc a b ↔ a < b | null | true |
DirectLimit.instSemifieldOfRingHomClass._proof_3 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
Units.val_mk | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (a b : α) (h₁ : a * b = 1) (h₂ : b * a = 1),
↑{ val := a, inv := b, val_inv := h₁, inv_val := h₂ } = a | null | true |
CochainComplex.mappingCone.map.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} (φ₁ : K₁ ⟶ L₁)
(φ₂ : K₂ ⟶ L₂) (a a_1 : K₁ ⟶ K₂) (e_a : a = a_1) (b b_1 : L₁ ⟶ L₂) (e_b : b = b_1)
(comm : CategoryTheory.... | null | true |
iteratedFDerivWithin_eq_iteratedFDeriv | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : ℕ},
UniqueDiffOn 𝕜 s → ContDiffAt 𝕜 (↑n) f x → x ∈ s → iteratedFDerivWithin... | null | true |
Lean.Meta.LazyDiscrTree.PartialMatch.noConfusion | Lean.Meta.LazyDiscrTree | {P : Sort u} →
{t t' : Lean.Meta.LazyDiscrTree.PartialMatch} → t = t' → Lean.Meta.LazyDiscrTree.PartialMatch.noConfusionType P t t' | null | false |
ContinuousMap.HomotopyEquiv.mk.sizeOf_spec | Mathlib.Topology.Homotopy.Equiv | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : SizeOf X]
[inst_3 : SizeOf Y] (toFun : C(X, Y)) (invFun : C(Y, X))
(left_inv : (invFun.comp toFun).Homotopic (ContinuousMap.id X))
(right_inv : (toFun.comp invFun).Homotopic (ContinuousMap.id Y)),
sizeOf { toFun := t... | null | true |
Algebra.IsStandardSmooth.mk | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(∃ ι σ, ∃ (x : Finite σ), Finite ι ∧ Nonempty (Algebra.SubmersivePresentation R S ι σ)) → Algebra.IsStandardSmooth R S | null | true |
Std.Http.Protocol.H1.Direction.swap | Std.Http.Protocol.H1.Message | Std.Http.Protocol.H1.Direction → Std.Http.Protocol.H1.Direction | Inverts the message direction.
| true |
CategoryTheory.shrinkYonedaEquiv_shrinkYoneda_map | Mathlib.CategoryTheory.ShrinkYoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] {X Y : C}
(f : X ⟶ Y),
CategoryTheory.shrinkYonedaEquiv (CategoryTheory.shrinkYoneda.{w, v, u}.map f) =
CategoryTheory.shrinkYonedaObjObjEquiv.symm f | null | true |
skyscraperPresheafCoconeOfSpecializes | Mathlib.Topology.Sheaves.Skyscraper | {X : TopCat} →
(p₀ : ↑X) →
[inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] →
{C : Type v} →
[inst_1 : CategoryTheory.Category.{u, v} C] →
(A : C) →
[inst_2 : CategoryTheory.Limits.HasTerminal C] →
{y : ↑X} →
p₀ ⤳ y →
... | The cocone at `A` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∈ closure {p₀}`
| true |
LinearMap.ofIsCompl_eq | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {p q : Submodule R E} (h : IsCompl p q) {φ : ↥p →ₗ[R] F}
{ψ : ↥q →ₗ[R] F} {χ : E →ₗ[R] F}, (∀ (u : ↥p), φ u = χ ↑u) → (∀ (u : ↥q), ψ u = χ ↑u) → LinearMap.of... | null | true |
CategoryTheory.instInhabitedFreeMonoidalCategory.default | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} → CategoryTheory.FreeMonoidalCategory C | null | true |
TestFunction.instZero._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type u_2} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞}, ContDiff ℝ ↑n fun x => 0 | null | false |
CompactlySupportedContinuousMap.toReal_apply | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} [inst : TopologicalSpace α] (f : CompactlySupportedContinuousMap α NNReal) (x : α), f.toReal x = ↑(f x) | null | true |
_private.Mathlib.Topology.Separation.Profinite.0.exists_clopen_partition_of_clopen_cover._proof_1_7 | Mathlib.Topology.Separation.Profinite | ∀ {X : Type u_1} [inst : TopologicalSpace X] {I : Type u_2} {D : Option I → Set X} (C' : I → Set X),
IsClopen (D none \ ⋃ i, C' i) → IsClopen ((fun i => Option.casesOn i (D none \ ⋃ i, C' i) C') none) | null | false |
CategoryTheory.Idempotents.KaroubiHomologicalComplexEquivalence.unitIso._proof_7 | Mathlib.CategoryTheory.Idempotents.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι},
CategoryTheory.CategoryStruct.comp
{ app := fun P => { f := { f := fun n => P.p.f n, comm' := ⋯ }, comm := ⋯ }, naturality := ⋯ }
{ app := fun P => { f := { f := fu... | null | false |
Aesop.mvarIdToSubgoal | Aesop.RuleTac.Basic | Lean.MVarId → Lean.MVarId → Aesop.BaseM Aesop.Subgoal | null | true |
OpenNormalAddSubgroup.instSetLike | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u} → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → SetLike (OpenNormalAddSubgroup G) G | null | true |
Std.HashMap.Raw.Equiv.of_forall_getKey?_unit_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {m₁ m₂ : Std.HashMap.Raw α Unit},
m₁.WF → m₂.WF → (∀ (k : α), m₁.getKey? k = m₂.getKey? k) → m₁.Equiv m₂ | null | true |
Lean.JsonRpc.Message._sizeOf_1 | Lean.Data.JsonRpc | Lean.JsonRpc.Message → ℕ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.