name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Data.ENat.Monoid.0.ENat.add_one_eq_coe_top_iff._simp_1_3 | Mathlib.Data.ENat.Monoid | ∀ (a : ℕ), (↑a = ⊤) = False | null | false |
CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence_inverse_obj_obj | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat))
(ι : Type u_1) [inst_1 : Unique ι] {X S : C} (f : X ⟶ S)
(A : (CategoryTheory.Adjunction.ofCat (F.map f.op.toLoc).adj).toCom... | null | true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂.epi_homologyMap_π | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) [inst_2 : CategoryTheory.EnoughInjectives C] (n q : ℤ),
q < n →
CategoryTheory.Epi
(HomologicalComplex.homologyMap (CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.st... | null | true |
ProbabilityTheory.«_aux_Mathlib_Probability_Distributions_Poisson_Basic___macroRules_ProbabilityTheory_termPo(_)_1» | Mathlib.Probability.Distributions.Poisson.Basic | Lean.Macro | null | false |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.inst._proof_21 | Mathlib.CategoryTheory.Bicategory.Monad.Basic | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B],
autoParam
(∀ {a b : CategoryTheory.Bicategory.OplaxTrans.ComonadBicat B} {f g : a ⟶ b} (η : f ⟶ g),
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.inst._aux_9 (CategoryTheory.CategoryStruct.id a) η =
CategoryTheory.CategoryStruct.comp (Catego... | null | false |
Lean.Elab.CommandContextInfo.mk.inj | Lean.Elab.InfoTree.Types | ∀ {env : Lean.Environment} {cmdEnv? : Option Lean.Environment} {fileMap : Lean.FileMap} {mctx : Lean.MetavarContext}
{options : Lean.Options} {currNamespace : Lean.Name} {openDecls : List Lean.OpenDecl} {ngen : Lean.NameGenerator}
{env_1 : Lean.Environment} {cmdEnv?_1 : Option Lean.Environment} {fileMap_1 : Lean.Fi... | null | true |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE_exact | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {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 l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | null | true |
List.rotate'_rotate'._f | Mathlib.Data.List.Rotate | ∀ {α : Type u} (x : ℕ)
(f : Nat.below (motive := fun x => ∀ (x_1 : List α) (x_2 : ℕ), (x_1.rotate' x).rotate' x_2 = x_1.rotate' (x + x_2)) x)
(x_1 : List α) (x_2 : ℕ), (x_1.rotate' x).rotate' x_2 = x_1.rotate' (x + x_2) | null | false |
Path.Homotopy.reflTransSymm._proof_5 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ : X} (p : Path x₀ x₁) (x : ↑unitInterval),
p ⟨Path.Homotopy.reflTransSymmAux (1, x), ⋯⟩ = (p.trans p.symm).toContinuousMap x | null | false |
_private.Mathlib.Topology.MetricSpace.CoveringNumbers.0.Metric.packingNumber_pos_iff._simp_1_1 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) | null | false |
Turing.ToPartrec.Code.prec | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Code → Turing.ToPartrec.Code → Turing.ToPartrec.Code | `prec f g` implements the `prec` (primitive recursion) operation of partial recursive
functions. `prec f g` evaluates as:
* `prec f g [] = [f []]`
* `prec f g (0 :: v) = [f v]`
* `prec f g (n+1 :: v) = [g (n :: prec f g (n :: v) :: v)]`
It is implemented as:
G (a :: b :: IH :: v) = (b :: a+1 :: b-1 :: g (a :: IH... | true |
Aesop.elabSimpTheorems | Aesop.RuleTac.ElabRuleTerm | Lean.Syntax →
Lean.Meta.Simp.Context →
Lean.Meta.Simp.SimprocsArray →
Bool → Lean.Elab.Tactic.TacticM (Lean.Meta.Simp.Context × Lean.Meta.Simp.SimprocsArray) | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.List.range'_eq_toList_rco._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {α : Type u_1} {l₁ l₂ : List α},
(l₁ = l₂) = (l₁.length = l₂.length ∧ ∀ (i : ℕ) (h₁ : i < l₁.length) (h₂ : i < l₂.length), l₁[i] = l₂[i]) | null | false |
Finset.subset_insert._simp_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), (s ⊆ insert a s) = True | null | false |
_private.Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset.0.Finset.zero_smul_subset._simp_1_2 | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : SMul α β] {s : Finset α} {t : Finset β} {x : β},
(x ∈ s • t) = ∃ y ∈ s, ∃ z ∈ t, y • z = x | null | false |
Std.ExtDHashMap.union | Std.Data.ExtDHashMap.Basic | {α : Type u} →
{β : α → Type v} →
{x : BEq α} →
{x_1 : Hashable α} →
[EquivBEq α] → [LawfulHashable α] → Std.ExtDHashMap α β → Std.ExtDHashMap α β → Std.ExtDHashMap α β | Computes the union of the given hash maps. If a key appears in both maps, the entry contained in
the second argument will appear in the result.
This function always merges the smaller map into the larger map, so the expected runtime is
`O(min(m₁.size, m₂.size))`.
| true |
multiplicity_one_right | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Monoid α] {a : α}, multiplicity a 1 = 0 | null | true |
Lean.Meta.LazyDiscrTree.ImportData.mk._flat_ctor | Lean.Meta.LazyDiscrTree | IO.Ref (Array Lean.Meta.LazyDiscrTree.ImportFailure) → Lean.Meta.LazyDiscrTree.ImportData | null | false |
_private.Mathlib.Algebra.Ring.Int.Parity.0.Int.odd_mul._simp_1_1 | Mathlib.Algebra.Ring.Int.Parity | ∀ {n : ℤ}, Odd n = ¬Even n | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Projection.0.isIdempotentElem_iff_spectrum_subset._proof_1_2 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Projection | ∀ (R : Type u_1) {A : Type u_2} [inst : Field R] [inst_6 : Ring A] [inst_8 : Algebra R A], IsScalarTower R A A | null | false |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Channel.Consumer.casesOn | Std.Http.Data.Body.Stream | {motive : Std.Http.Body.Channel.Consumer✝ → Sort u} →
(t : Std.Http.Body.Channel.Consumer✝) →
((promise : IO.Promise (Except IO.Error (Option Std.Http.Chunk))) →
motive (Std.Http.Body.Channel.Consumer.normal✝ promise)) →
((finished : Std.Async.Waiter (Option Std.Http.Chunk)) →
motive (Std.... | null | false |
TypeVec.«term_:::_» | Mathlib.Data.TypeVec | Lean.TrailingParserDescr | Support for extending a `TypeVec` by one element. | true |
List.mapWithPrefixSuffixAux._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → {β : Type u_2} → (List α → α → List α → β) → List α → List α → List β | null | false |
supClosed_preimage_toDual._simp_2 | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : Lattice α] {s : Set αᵒᵈ}, SupClosed (⇑OrderDual.toDual ⁻¹' s) = InfClosed s | null | false |
List.take_sum_flatten | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {α : Type u_2} (L : List (List α)) (i : ℕ),
List.take (List.take i (List.map List.length L)).sum L.flatten = (List.take i L).flatten | In a flatten, taking the first elements up to an index which is the sum of the lengths of the
first `i` sublists, is the same as taking the flatten of the first `i` sublists. | true |
ULift.semiring._proof_11 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
Lean.Meta.Grind.proveHEq? | Lean.Meta.Tactic.Grind.ProveEq | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM (Option Lean.Expr) | Similar to `proveEq?`, but for heterogeneous equality. | true |
Nat.div.go.congr_simp | Init.Data.Nat.Div.Basic | ∀ (y y_1 : ℕ) (e_y : y = y_1) (hy : 0 < y) (fuel fuel_1 : ℕ) (e_fuel : fuel = fuel_1) (x x_1 : ℕ) (e_x : x = x_1)
(hfuel : x < fuel), Nat.div.go y hy fuel x hfuel = Nat.div.go y_1 ⋯ fuel_1 x_1 ⋯ | null | true |
AddActionHom.prod | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_1} →
{N : Type u_2} →
{α : Type u_3} →
{γ : Type u_5} →
{δ : Type u_6} →
[inst : VAdd M α] →
[inst_1 : VAdd N γ] → [inst_2 : VAdd N δ] → {σ : M → N} → (α →ₑ[σ] γ) → (α →ₑ[σ] δ) → α →ₑ[σ] γ × δ | If `f` and `g` are equivariant maps, then so is `x ↦ (f x, g x)`. | true |
Std.DHashMap.getKey_diff | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {h_mem : k ∈ m₁ \ m₂}, (m₁ \ m₂).getKey k h_mem = m₁.getKey k ⋯ | null | true |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.universalFactorizationMapPresentation_jacobiMatrix._proof_1_4 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (m k : ℕ) (i : Fin m) (i_1 : Fin k), m + ↑i_1 - ↑i + 1 ≤ k → m + ↑i_1 - ↑i < k | null | false |
_private.Mathlib.Topology.Category.CompHaus.EffectiveEpi.0.CompHaus.instPreregular._proof_1 | Mathlib.Topology.Category.CompHaus.EffectiveEpi | 1 ≠ 0 | null | false |
TensorProduct.prodLeft._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Prod | ∀ (R : Type u_1) (S : Type u_2) (M₁ : Type u_4) (M₂ : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : Algebra R S] [inst_5 : Module R M₁]
[inst_6 : Module S M₁] [IsScalarTower R S M₁] [inst_8 : Module R M₂] [inst_9 : Module S M₂] [IsScalarTow... | null | false |
Vector.isSome_find? | Init.Data.Vector.Find | ∀ {α : Type} {n : ℕ} {xs : Vector α n} {f : α → Bool}, (Vector.find? f xs).isSome = xs.any fun x => f x | null | true |
Ideal.exists_disjoint_powers_of_span_eq_top | Mathlib.RingTheory.Ideal.Maximal | ∀ {α : Type u} [inst : CommSemiring α] (s : Set α),
Ideal.span s = ⊤ → ∀ (I : Ideal α), I ≠ ⊤ → ∃ r ∈ s, Disjoint ↑I ↑(Submonoid.powers r) | null | true |
Set.Ico_add_Icc_subset | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Add α] [inst_1 : PartialOrder α] [AddLeftStrictMono α] [AddRightStrictMono α] (a b c d : α),
Set.Ico a b + Set.Icc c d ⊆ Set.Ico (a + c) (b + d) | null | true |
_private.Mathlib.Topology.Compactness.Compact.0.IsClosed.exists_minimal_nonempty_closed_subset._simp_1_5 | Mathlib.Topology.Compactness.Compact | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
ENormedAddMonoid.rec | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} →
[inst : TopologicalSpace E] →
{motive : ENormedAddMonoid E → Sort u} →
([toESeminormedAddMonoid : ESeminormedAddMonoid E] →
(enorm_eq_zero : ∀ (x : E), ‖x‖ₑ = 0 ↔ x = 0) →
motive { toESeminormedAddMonoid := toESeminormedAddMonoid, enorm_eq_zero := enorm_eq_zero }) →
... | null | false |
eq_of_forall_lt_iff | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] {a b : α}, (∀ (c : α), c < a ↔ c < b) → a = b | null | true |
CategoryTheory.ShortComplex.HomologyMapData.natTransApp_left | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {S : CategoryTheory.ShortComplex C}
{F G : CategoryTheory.Functor C D} [inst_4 : F.P... | null | true |
CategoryTheory.Limits.preservesLimit_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] (K : CategoryTheory.Functor J Cᵒᵖ)
(F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.Limits.PreservesColimit K.leftOp F],
CategoryTheor... | If `F : C ⥤ Dᵒᵖ` preserves colimits of `K.leftOp : Jᵒᵖ ⥤ C`, then `F.leftOp : Cᵒᵖ ⥤ D`
preserves limits of `K : J ⥤ Cᵒᵖ`. | true |
UniformEquiv.coe_punitProd | Mathlib.Topology.UniformSpace.Equiv | ∀ (α : Type u) [inst : UniformSpace α], ⇑(UniformEquiv.punitProd α) = Prod.snd | null | true |
SeminormedAddCommGroup.toSeminormedAddGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_2} → [SeminormedAddCommGroup E] → SeminormedAddGroup E | null | true |
Turing.TM2Computable.mk.sizeOf_spec | Mathlib.Computability.TuringMachine.Computable | ∀ {α β αΓ βΓ : Type} {ea : α → List αΓ} {eb : β → List βΓ} {f : α → β} [inst : SizeOf α] [inst_1 : SizeOf β]
[inst_2 : SizeOf αΓ] [inst_3 : SizeOf βΓ] (toTM2ComputableAux : Turing.TM2ComputableAux αΓ βΓ)
(outputsFun :
(a : α) →
Turing.TM2Outputs toTM2ComputableAux.tm (List.map toTM2ComputableAux.inputAlph... | null | true |
GradedRing.projZeroRingHom._proof_3 | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_3} {A : Type u_1} {σ : Type u_2} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddCommMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] (𝒜 : ι → σ) [inst_5 : GradedRing 𝒜] (x x_1 : A),
↑(((DirectSum.decompose 𝒜) (x + x_1)) 0) = ↑(((DirectSum.decompose 𝒜) x) 0) + ↑(((Direct... | null | false |
UInt16.one_mul | Init.Data.UInt.Lemmas | ∀ (a : UInt16), 1 * a = a | null | true |
_private.Lean.Meta.GetUnfoldableConst.0.Lean.Meta.getUnfoldableConstNoEx?._sparseCasesOn_1 | Lean.Meta.GetUnfoldableConst | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
((val : Lean.AxiomVal) → motive (Lean.ConstantInfo.axiomInfo val)) →
(Nat.hasNotBi... | null | false |
CategoryTheory.Functor.mapMon_obj_mon_mul | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] (A : CategoryTheory.Mon C),
CategoryTheory.Mon... | null | true |
maximal_le_iff | Mathlib.Order.Minimal | ∀ {α : Type u_2} {x y : α} [inst : PartialOrder α], Maximal (fun x => x ≤ y) x ↔ x = y | null | true |
differentiableAt_iteratedDerivWithin_cexp | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ (n a : ℕ) {s : Set ℂ},
IsOpen s →
∀ {r : ℂ},
r ∈ s → DifferentiableAt ℂ (iteratedDerivWithin a (fun z => Complex.exp (2 * ↑Real.pi * Complex.I * z) ^ n) s) r | null | true |
ProofWidgets.ExprPresentationProps.mk.inj | ProofWidgets.Presentation.Expr | ∀ {expr expr_1 : Lean.Server.WithRpcRef ProofWidgets.ExprWithCtx}, { expr := expr } = { expr := expr_1 } → expr = expr_1 | null | true |
Subsemiring.instSetLike | Mathlib.Algebra.Ring.Subsemiring.Defs | {R : Type u} → [inst : NonAssocSemiring R] → SetLike (Subsemiring R) R | null | true |
ModularForm.instGCommRing._proof_7 | Mathlib.NumberTheory.ModularForms.Basic | ∀ (Γ : Subgroup (GL (Fin 2) ℝ)) [inst : Γ.HasDetPlusMinusOne] (x : GradedMonoid (ModularForm Γ)), 1 * x = x | null | false |
_private.Mathlib.Data.Stream.Init.0.Stream'.cons.match_1.eq_2 | Mathlib.Data.Stream.Init | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n | null | true |
Mathlib.Tactic.Polynomial._aux_Mathlib_Tactic_Polynomial_Basic___macroRules_Mathlib_Tactic_Polynomial_tacticPolynomial_nf!__1 | Mathlib.Tactic.Polynomial.Basic | Lean.Macro | null | false |
Nat.toArray_toList_roo | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m<...n).toList.toArray = (m<...n).toArray | null | true |
LDL.lowerInv_eq_gramSchmidtBasis | Mathlib.Analysis.Matrix.LDL | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : LinearOrder n] [inst_2 : LocallyFiniteOrderBot n]
{S : Matrix n n 𝕜} [inst_3 : Fintype n] (hS : S.PosDef),
LDL.lowerInv hS = ((Pi.basisFun 𝕜 n).toMatrix ⇑(InnerProductSpace.gramSchmidtBasis (Pi.basisFun 𝕜 n))).transpose | null | true |
Function.locallyFinsupp.map.eq_1 | Mathlib.Topology.LocallyFinsupp.Pushforward | ∀ {X : Type u_1} {Y : Type u_2} {R : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y)
(w : X → R) [inst_2 : Semiring R] [inst_3 : PrespectralSpace Y] (hf : IsSpectralMap f)
(c : Function.locallyFinsupp X R),
Function.locallyFinsupp.map f w hf c =
{ toFun := fun z => ∑ᶠ (x : X) (... | null | true |
_private.Mathlib.Algebra.Homology.CochainComplexOpposite.0.CochainComplex.exactAt_op._proof_1_2 | Mathlib.Algebra.Homology.CochainComplexOpposite | ∀ (m : ℤ), (ComplexShape.up ℤ).prev (-m) = -(m + 1) | null | false |
String.Pos.Raw.IsValidForSlice | Init.Data.String.Defs | String.Slice → String.Pos.Raw → Prop | Criterion for validity of positions in string slices. | true |
SimpleGraph.Walk.IsHamiltonian.congr_simp | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} {inst : DecidableEq α} [inst_1 : DecidableEq α] {G : SimpleGraph α} {a b : α} (p p_1 : G.Walk a b),
p = p_1 → p.IsHamiltonian = p_1.IsHamiltonian | null | true |
Nat.Internal.Linear.Poly.denote_le | Init.Data.Nat.Internal.Linear | Nat.Internal.Linear.Context → Nat.Internal.Linear.Poly × Nat.Internal.Linear.Poly → Prop | null | true |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.castSucc_lt_or_lt_succ._simp_1_1 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {a b : Fin n}, (a < b) = (↑a < ↑b) | null | false |
Array.find?_eq_bind_findIdx?_getElem? | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool}, Array.find? p xs = (Array.findIdx? p xs).bind fun x => xs[x]? | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.Reduced.0.RootPairing.pairing_neg_one_neg_four_iff'._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Reduced | ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (a = -b) = (-a = b) | null | false |
MvPowerSeries.rescale_rescale | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_9} [inst : CommSemiring R] (f : MvPowerSeries σ R) (a b : σ → R),
(MvPowerSeries.rescale b) ((MvPowerSeries.rescale a) f) = (MvPowerSeries.rescale (a * b)) f | null | true |
CategoryTheory.Subobject.factors_of_le | Mathlib.CategoryTheory.Subobject.FactorThru | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y Z : C} {P Q : CategoryTheory.Subobject Y} (f : Z ⟶ Y),
P ≤ Q → P.Factors f → Q.Factors f | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.Base.0.RootPairing.Base.root_mem_span_int._simp_1_2 | Mathlib.LinearAlgebra.RootSystem.Base | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M)
(x : M), (x ∈ p.toAddSubmonoid) = (x ∈ p) | null | false |
lt_mul_inv_iff_mul_lt._simp_2 | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LT α] [MulRightStrictMono α] {a b c : α}, (c < a * b⁻¹) = (c * b < a) | null | false |
instWeaklyLawfulMonadAttachStateRefT'OfLawfulMonad | Init.Control.Lawful.MonadAttach.Instances | ∀ {m : Type → Type} {ω σ : Type} [inst : Monad m] [inst_1 : MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m],
WeaklyLawfulMonadAttach (StateRefT' ω σ m) | null | true |
Real.logb_nonneg_iff_of_base_lt_one | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x : ℝ}, 0 < b → b < 1 → 0 < x → (0 ≤ Real.logb b x ↔ x ≤ 1) | null | true |
MvPowerSeries.instAlgebra | Mathlib.RingTheory.MvPowerSeries.Basic | {σ : Type u_1} →
{R : Type u_2} →
{A : Type u_3} → [inst : CommSemiring R] → [inst_1 : Semiring A] → [Algebra R A] → Algebra R (MvPowerSeries σ A) | null | true |
_private.Mathlib.Probability.Independence.Integration.0.ProbabilityTheory.IndepFun.integral_bilin_comp_comp'.match_1_3 | Mathlib.Probability.Independence.Integration | ∀ {Ω : Type u_2} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝓧 : Type u_5} {𝓨 : Type u_4} {E : Type u_1}
{F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] {X : Ω → 𝓧} {Y : Ω → 𝓨} {f : 𝓧 → E}
{g : 𝓨 → F}
(motive : MeasureTheory.Integrable (fun ω => f (X ω)) μ ∧ MeasureT... | null | false |
PresheafOfModules.Hom.app | Mathlib.Algebra.Category.ModuleCat.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
{M₁ M₂ : PresheafOfModules R} → M₁.Hom M₂ → (X : Cᵒᵖ) → M₁.obj X ⟶ M₂.obj X | a family of linear maps `M₁.obj X ⟶ M₂.obj X` for all `X`. | true |
_private.Mathlib.Topology.MetricSpace.Gluing.0.Metric.Sum.dist_comm | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u} {Y : Type v} [inst : MetricSpace X] [inst_1 : MetricSpace Y] (x y : X ⊕ Y),
Metric.Sum.dist x y = Metric.Sum.dist y x | null | true |
Mathlib.Meta.NormNum.asc_factorial_aux | Mathlib.Tactic.NormNum.NatFactorial | ∀ (n l m a b : ℕ), n.ascFactorial l = a → (n + l).ascFactorial m = b → n.ascFactorial (l + m) = a * b | null | true |
Specialization.ofEquiv_specializes_ofEquiv | Mathlib.Topology.Specialization | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a b : Specialization α},
Specialization.ofEquiv a ⤳ Specialization.ofEquiv b ↔ b ≤ a | null | true |
Lean.Parser.AliasValue.binary.elim | Lean.Parser.Extension | {α : Type} →
{motive : Lean.Parser.AliasValue α → Sort u} →
(t : Lean.Parser.AliasValue α) →
t.ctorIdx = 2 → ((p : α → α → α) → motive (Lean.Parser.AliasValue.binary p)) → motive t | null | false |
posPart_max | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : SubNegMonoid α] (a b : α), (a ⊔ b)⁺ = a⁺ ⊔ b⁺ | null | true |
Lean.Parser.Command.theorem | Lean.Parser.Command | Lean.Parser.Parser | null | true |
Lean.Elab.instInhabitedTerminationBy | Lean.Elab.PreDefinition.TerminationHint | Inhabited Lean.Elab.TerminationBy | null | true |
ContinuousAt.comp_of_eq | Mathlib.Topology.Continuous | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f : X → Y} {x : X} {y : Y} {g : Y → Z},
ContinuousAt g y → ContinuousAt f x → f x = y → ContinuousAt (g ∘ f) x | See note [comp_of_eq lemmas] | true |
Lean.Parser.Attr.export.parenthesizer | Lean.Parser.Attr | Lean.PrettyPrinter.Parenthesizer | null | true |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkAndIntroN.go._sunfold | Lean.Meta.AppBuilder | List Lean.Expr → Lean.MetaM (Lean.Expr × Lean.Expr) | null | false |
Matrix.reindexRingEquiv_refl | Mathlib.LinearAlgebra.Matrix.Reindex | ∀ {n : Type u_2} (R : Type u_9) [inst : Fintype n] [inst_1 : Mul R] [inst_2 : AddCommMonoid R],
Matrix.reindexRingEquiv R (Equiv.refl n) = RingEquiv.refl (Matrix n n R) | null | true |
Std.Iter.forIn_filterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β γ : Type w} [inst : Std.Iterator α Id β] {n : Type w → Type w''} {o : Type w → Type u_1} [inst_1 : Monad n]
[LawfulMonad n] [inst_3 : Monad o] [LawfulMonad o] [inst_5 : MonadAttach n] [WeaklyLawfulMonadAttach n]
[inst_7 : MonadLiftT n o] [LawfulMonadLiftT n o] [Std.Iterators.Finite α Id] [inst_10 : Std.Itera... | null | true |
_private.Init.GrindInstances.Ring.SInt.0.Lean.Grind.instIsCharPInt8HPowNatOfNat._simp_3 | Init.GrindInstances.Ring.SInt | ∀ {m n : ℕ}, (n % m = 0) = (m ∣ n) | null | false |
FreeAddMonoid.toList_ofList | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} (l : List α), FreeAddMonoid.toList (FreeAddMonoid.ofList l) = l | null | true |
IsConnected.isPreconnected | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, IsConnected s → IsPreconnected s | null | true |
MeasureTheory.L1.integral | Mathlib.MeasureTheory.Integral.Bochner.L1 | {α : Type u_5} →
{E : Type u_6} →
[inst : NormedAddCommGroup E] →
{m : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} → [NormedSpace ℝ E] → [CompleteSpace E] → ↥(MeasureTheory.Lp E 1 μ) → E | The Bochner integral in L1 space | true |
_private.Mathlib.CategoryTheory.Presentable.Comma.0.CategoryTheory.Comma.isCardinalAccessibleCategory.π₂._proof_4 | Mathlib.CategoryTheory.Presentable.Comma | ∀ {C₁ : Type u_6} {C₂ : Type u_2} {D : Type u_7} [inst : CategoryTheory.Category.{u_4, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_7} D]
{F₁ : CategoryTheory.Functor C₁ D} {F₂ : CategoryTheory.Functor C₂ D} (κ : Cardinal.{u_3}) [inst_3 : Fact κ.IsRegular]
(f... | null | false |
SimplexCategory.diag_subinterval_eq | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} (j l : ℕ) (hjl : j + l ≤ n),
CategoryTheory.CategoryStruct.comp (SimplexCategory.diag l) (SimplexCategory.subinterval j l hjl) =
SimplexCategory.intervalEdge j l hjl | null | true |
Equiv.pSigmaAssoc._proof_1 | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : α → Sort u_2} (γ : (a : α) → β a → Sort u_3),
Function.LeftInverse (fun x => ⟨⟨x.fst, x.snd.fst⟩, x.snd.snd⟩) fun x => ⟨x.fst.fst, ⟨x.fst.snd, x.snd⟩⟩ | null | false |
_private.Mathlib.Topology.MetricSpace.Gluing.0.Metric.glueDist_triangle_inl_inr_inr | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u} {Y : Type v} {Z : Type w} [inst : MetricSpace X] [inst_1 : MetricSpace Y] [Nonempty Z] (Φ : Z → X)
(Ψ : Z → Y) (ε : ℝ) (x : X) (y z : Y),
Metric.glueDist Φ Ψ ε (Sum.inl x) (Sum.inr z) ≤
Metric.glueDist Φ Ψ ε (Sum.inl x) (Sum.inr y) + Metric.glueDist Φ Ψ ε (Sum.inr y) (Sum.inr z) | null | true |
GaussianInt.toComplex_eq_zero | Mathlib.NumberTheory.Zsqrtd.GaussianInt | ∀ {x : GaussianInt}, GaussianInt.toComplex x = 0 ↔ x = 0 | null | true |
CategoryTheory.ShortComplex.Splitting.leftHomologyData_π | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C} [inst_2 : CategoryTheory.Limits.HasZeroObject C] (s : S.Splitting),
s.leftHomologyData.π = 0 | null | true |
ContinuousLinearMap.norm_id | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : SeminormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] [NontrivialTopology E], ‖ContinuousLinearMap.id 𝕜 E‖ = 1 | If a normed space is (topologically) non-trivial, then the norm of the identity equals `1`. | true |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.addAux.match_1.eq_2 | Mathlib.SetTheory.Ordinal.Notation | ∀ (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.eq with
| Ordering.lt => h_1 ()
| Ordering.eq => h_2 ()
| Ordering.gt => h_3 ()) =
h_2 () | null | true |
PositiveLinearMap.zero_apply | Mathlib.Algebra.Order.Module.PositiveLinearMap | ∀ {R : Type u_1} {E₁ : Type u_2} {E₂ : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid E₁]
[inst_2 : PartialOrder E₁] [inst_3 : AddCommMonoid E₂] [inst_4 : PartialOrder E₂] [inst_5 : Module R E₁]
[inst_6 : Module R E₂] (x : E₁), 0 x = 0 | null | true |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.exists_closed_cover_approximatesLinearOn_of_hasFDerivWithinAt._simp_1_1 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.