name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SymbolicDynamics.FullShift.Pattern.casesOn | Mathlib.Dynamics.SymbolicDynamics.Basic | {A : Type u_1} →
{G : Type u_2} →
[inst : Inhabited A] →
{motive : SymbolicDynamics.FullShift.Pattern A G → Sort u} →
(t : SymbolicDynamics.FullShift.Pattern A G) →
((config : G → A) →
(support : Finset G) →
(condition : ∀ g ∉ support, config g = default) →
... | null | false |
_private.Init.Data.Array.MapIdx.0.Array.mapFinIdx_induction.go | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} (xs : Array α) (f : (i : ℕ) → α → i < xs.size → β) (motive : ℕ → Prop)
(p : (i : ℕ) → β → i < xs.size → Prop),
(∀ (i : ℕ) (h : i < xs.size), motive i → p i (f i xs[i] h) h ∧ motive (i + 1)) →
∀ {bs : Array β} {i j : ℕ} {h : i + j = xs.size},
j = bs.size →
(∀ (i : ℕ)... | null | true |
CategoryTheory.Limits.createsColimitsOfShapeRightOp | Mathlib.CategoryTheory.Limits.Preserves.Creates.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] →
(F : CategoryTheory.Functor Cᵒᵖ D) →
[CategoryTheory.CreatesLimitsOfShape Jᵒ... | If `F : Cᵒᵖ ⥤ D` creates limits of shape `Jᵒᵖ`, then `F.rightOp : C ⥤ Dᵒᵖ` creates colimits
of shape `J`. | true |
Lean.Grind.NoopConfig.matchEqs._inherited_default | Init.Grind.Config | Bool | null | false |
Lean.Lsp.DocumentSymbol.ctorIdx | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.DocumentSymbol → ℕ | null | false |
LinearMap.compr₂.congr_simp | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {A : Type u_1} {R : Type u_2} [inst : Semiring A] [inst_1 : CommSemiring R] {M : Type u_5} {Nₗ : Type u_8}
{Pₗ : Type u_9} {Qₗ : Type u_10} [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid Nₗ] [inst_4 : AddCommMonoid Pₗ]
[inst_5 : AddCommMonoid Qₗ] [inst_6 : Module R Nₗ] [inst_7 : Module R Pₗ] [inst_8 : Module ... | null | true |
_private.Mathlib.Analysis.Normed.Operator.BoundedLinearMaps.0.IsBoundedLinearMap.comp.match_1_1 | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {𝕜 : Type u_1} {F : Type u_2} {G : Type u_3} [inst : Semiring 𝕜] [inst_1 : SeminormedAddCommGroup F]
[inst_2 : Module 𝕜 F] [inst_3 : SeminormedAddCommGroup G] [inst_4 : Module 𝕜 G] {g : F → G}
(motive : IsBoundedLinearMap 𝕜 g → Prop) (hg : IsBoundedLinearMap 𝕜 g),
(∀ (hlg : IsLinearMap 𝕜 g) (Mg : ℝ) (lef... | null | false |
IsAntichain.partiallyWellOrderedOn_iff | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {r : α → α → Prop} {s : Set α} [Std.Refl r], IsAntichain r s → (s.PartiallyWellOrderedOn r ↔ s.Finite) | null | true |
Lean.Parser.«_aux_Init_CbvSimproc___macroRules_Lean_Parser_command__Builtin_cbv_simproc____(_):=__1» | Init.CbvSimproc | Lean.Macro | null | false |
_private.Mathlib.Basic.Rel.0.SetRel.preimage_univ_right._proof_1_1 | Mathlib.Basic.Rel | ∀ {α : Type u_1} {β : Type u_2} {R : SetRel α β}, R.preimage Set.univ = R.dom | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.chainBotCoeff_if_one_zero._proof_1_3 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} [inst_5 : Finite ι]
[inst_6 : CharZero R] [inst_7 : IsDomain R] {i j : ι} [inst_8 : P.IsNotG2],
RootPairing.ch... | null | false |
FreeGroup.startsWith.ne_one | Mathlib.GroupTheory.FreeGroup.Orbit | ∀ {α : Type u_1} [inst : DecidableEq α] {w : α × Bool}, ∀ g ∈ FreeGroup.startsWith w, g ≠ 1 | The neutral element is not contained in one of the startsWith sets.
| true |
_private.Mathlib.Analysis.Convex.Intrinsic.0.preimage_image_eq_of_homeomorph_affineSpan.match_1_1 | Mathlib.Analysis.Convex.Intrinsic | ∀ {𝕜 : Type u_2} {V : Type u_3} {Q : Type u_4} {P : Type u_1} [inst : Ring 𝕜] [inst_1 : AddCommGroup V]
[inst_2 : Module 𝕜 V] [inst_3 : AddTorsor V P] {f : P → Q} {s : Set P} (x : ↥(affineSpan 𝕜 s))
(motive : x ∈ f ∘ Subtype.val ⁻¹' f '' s → Prop) (x_1 : x ∈ f ∘ Subtype.val ⁻¹' f '' s),
(∀ (w : P) (hy : w ∈ s... | null | false |
YoungDiagram.equivPartition | Mathlib.Combinatorics.Enumerative.Partition.YoungDiagram | {n : ℕ} → { μ // μ.card = n } ≃ n.Partition | Equivalence between Young diagrams of cardinality `n` and partitions of `n`. | true |
Lean.Grind.Fin.ofNat_succ | Init.GrindInstances.Ring.Fin | ∀ {n : ℕ} [inst : NeZero n] (a : ℕ), OfNat.ofNat (a + 1) = OfNat.ofNat a + 1 | null | true |
MeasureTheory.AEEqFun.lintegral | Mathlib.MeasureTheory.Function.AEEqFun | {α : Type u_1} → [inst : MeasurableSpace α] → {μ : MeasureTheory.Measure α} → (α →ₘ[μ] ENNReal) → ENNReal | For `f : α → ℝ≥0∞`, define `∫ [f]` to be `∫ f` | true |
instPreservesColimitsOfShapeSheafTypeUliftYonedaOfPreservesLimitsOfShapeOppositeObjFunctorIsSheaf | Mathlib.CategoryTheory.Sites.PreservesLimits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
[inst_1 : J.Subcanonical] {K : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} K]
[∀ (X : CategoryTheory.Sheaf J (Type (max v v'))), CategoryTheory.Limits.PreservesLimitsOfShape Kᵒᵖ X.obj],
CategoryTheory.L... | null | true |
Std.TreeMap.getKey!_erase_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{k : α}, (t.erase k).getKey! k = default | null | true |
Quot.pliftOn | Init.Core | {β : Sort u_1} →
{α : Sort u} →
{r : α → α → Prop} →
(q : Quot r) →
(f : (a : α) → q = Quot.mk r a → β) →
(∀ (a b : α) (h : q = Quot.mk r a) (h' : q = Quot.mk r b), r a b → f a h = f b h') → β | Like `Quot.liftOn q f h` but allows `f a` to "know" that `q = Quot.mk r a`.
| true |
principal_inter_le_nhdsSetWithin | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : Set α}, Filter.principal (s ∩ t) ≤ nhdsSetWithin s t | null | true |
liminf_finset_inf'._auto_1 | Mathlib.Order.LiminfLimsup | Lean.Syntax | null | false |
Function.Injective.addCommSemigroup | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Add M₁] →
[inst_1 : AddCommSemigroup M₂] →
(f : M₁ → M₂) → Function.Injective f → (∀ (x y : M₁), f (x + y) = f x + f y) → AddCommSemigroup M₁ | A type endowed with `+` is an additive commutative semigroup,if it admits
an injective map that preserves `+` to an additive commutative semigroup. | true |
LieAlgebra.Orthogonal.soIndefiniteEquiv_apply | Mathlib.Algebra.Lie.Classical | ∀ (p : Type u_2) (q : Type u_3) (R : Type u₂) [inst : DecidableEq p] [inst_1 : DecidableEq q] [inst_2 : CommRing R]
[inst_3 : Fintype p] [inst_4 : Fintype q] {i : R} (hi : i * i = -1) (A : ↥(LieAlgebra.Orthogonal.so' p q R)),
↑((LieAlgebra.Orthogonal.soIndefiniteEquiv p q R hi) A) =
(LieAlgebra.Orthogonal.Pso p... | null | true |
Std.Tactic.BVDecide.BVExpr.const.sizeOf_spec | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (val : BitVec w), sizeOf (Std.Tactic.BVDecide.BVExpr.const val) = 1 + sizeOf w + sizeOf val | null | true |
Polynomial.isRoot_gcd_iff_isRoot_left_right | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : Field R] [inst_1 : DecidableEq R] {f g : Polynomial R} {α : R},
(EuclideanDomain.gcd f g).IsRoot α ↔ f.IsRoot α ∧ g.IsRoot α | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Limits.HasLimits.0.CategoryTheory.MonoidalCategory.Limits.HasColimit.isoOfNatIso_ι_hom_whiskerRight._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Limits.HasLimits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y : C}
(f : W ⟶ X) (g : X ⟶ Y) (Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z)
(CategoryTheory.MonoidalCategoryStruct.whiskerRight g Z) =
Category... | null | false |
_private.Mathlib.Tactic.ClickSuggestions.Unfold.0.Mathlib.Tactic.ClickSuggestions.unfoldProjDefaultInst?._sparseCasesOn_1 | Mathlib.Tactic.ClickSuggestions.Unfold | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
AddOpposite.instMeasurableMul₂ | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} [inst : Add M] [inst_1 : MeasurableSpace M] [MeasurableAdd₂ M], MeasurableAdd₂ Mᵃᵒᵖ | null | true |
sup_sub_inf_eq_abs_sub | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a b : α), a ⊔ b - a ⊓ b = |b - a| | null | true |
BooleanSubalgebra.val_inf | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {L : BooleanSubalgebra α} (a b : ↥L), ↑(a ⊓ b) = ↑a ⊓ ↑b | null | true |
Subsemiring.isMulCommutative_topologicalClosure | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Semiring R] [inst_2 : IsSemitopologicalSemiring R] [T2Space R]
(s : Subsemiring R) [IsMulCommutative ↥s], IsMulCommutative ↥s.topologicalClosure | If a subsemiring of a topological semiring is commutative, then so is its
topological closure. | true |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.size_eq_realSize.match_1_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (motive : (x : Ordnode α) → x.Sized → Prop) (x : Ordnode α) (x_1 : x.Sized),
(∀ (x : Ordnode.nil.Sized), motive Ordnode.nil x) →
(∀ (s : ℕ) (l : Ordnode α) (x : α) (r : Ordnode α) (h₁ : s = l.size + r.size + 1) (h₂ : l.Sized) (h₃ : r.Sized),
motive (Ordnode.node s l x r) ⋯) →
motive... | null | false |
CategoryTheory.Functor.leftKanExtensionCompIsoOfPreserves.eq_1 | 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... | null | true |
Bool.lt_iff | Mathlib.Data.Bool.Basic | ∀ {x y : Bool}, x < y ↔ x = false ∧ y = true | null | true |
Lean.Meta.FunInd.instHashableCall.hash | Lean.Meta.Tactic.FunIndCollect | Lean.Meta.FunInd.Call → UInt64 | null | true |
Lean.Level.getParamSubst._unsafe_rec | Lean.Level | List Lean.Name → List Lean.Level → Lean.Name → Option Lean.Level | null | false |
Std.HashMap.Raw.getKey?_union_of_not_mem_left | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₁ → (m₁ ∪ m₂).getKey? k = m₂.getKey? k | null | true |
SimpleGraph.IsAlternating.sup_edge | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {V : Type u_1} {G G' : SimpleGraph V} {u x : V},
G.IsAlternating G' →
¬G'.Adj u x →
(∀ (u' : V), u' ≠ u → G.Adj x u' → G'.Adj x u') →
(∀ (x' : V), x' ≠ x → G.Adj x' u → G'.Adj x' u) → (G ⊔ SimpleGraph.edge u x).IsAlternating G' | null | true |
Int32.mul_zero | Init.Data.SInt.Lemmas | ∀ {a : Int32}, a * 0 = 0 | null | true |
Set.image2_right_comm | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {δ' : Type u_8} {ε : Type u_9} {s : Set α} {t : Set β}
{u : Set γ} {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε},
(∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b) →
Set.image2 f (Set.image2 g s t) u = Set.image2 g' (Set.... | null | true |
Fintype.equivOfCardEq.congr_simp | Mathlib.Analysis.Matrix.Spectrum | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (h : Fintype.card α = Fintype.card β),
Fintype.equivOfCardEq h = Fintype.equivOfCardEq h | null | true |
Std.Time.TimeZone.TZif.LocalTimeType.mk.noConfusion | Std.Time.Zoned.Database.TzIf | {P : Sort u} →
{gmtOffset : ℤ} →
{isDst : Bool} →
{abbreviationIndex : UInt8} →
{gmtOffset' : ℤ} →
{isDst' : Bool} →
{abbreviationIndex' : UInt8} →
{ gmtOffset := gmtOffset, isDst := isDst, abbreviationIndex := abbreviationIndex } =
{ gmtOffset :... | null | false |
Polynomial.mem_support_iff | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R}, n ∈ p.support ↔ p.coeff n ≠ 0 | null | true |
Set.eq_empty_of_subset_empty | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s : Set α}, s ⊆ ∅ → s = ∅ | null | true |
LinearMap.inr_apply | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (x : M₂), (LinearMap.inr R M M₂) x = (0, x) | null | true |
_private.Mathlib.Algebra.Lie.TraceForm.0.LieModule.isLieAbelian_of_ker_traceForm_eq_bot._simp_1_1 | Mathlib.Algebra.Lie.TraceForm | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b ≤ ⊥) | null | false |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.warnUnusedSimpArgs.match_1 | Lean.Elab.Tactic.Simp | (motive : Lean.Meta.SimpEntry → Sort u_1) →
(x : Lean.Meta.SimpEntry) →
((thm : Lean.Meta.SimpTheorem) → motive (Lean.Meta.SimpEntry.thm thm)) →
((declName : Lean.Name) → motive (Lean.Meta.SimpEntry.toUnfold declName)) →
((_declName : Lean.Name) →
(thms : Array Lean.Name) → motive (Lean.... | null | false |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Sub.0.MeasureTheory.exists_setLIntegral_compl_lt._simp_1_1 | Mathlib.MeasureTheory.Integral.Lebesgue.Sub | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
LocallyConstant.neg_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Neg Y] (f : LocallyConstant X Y) (x : X),
(-f) x = -f x | null | true |
Int.Internal.Linear.Poly.noConfusionType | Init.Data.Int.Linear | Sort u → Int.Internal.Linear.Poly → Int.Internal.Linear.Poly → Sort u | null | false |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.hasSingleAcceptedHostHeader | Std.Http.Protocol.H1 | Std.Http.Protocol.H1.Message.Head Std.Http.Protocol.H1.Direction.receiving → Bool | Validates the required `Host` header for HTTP/1.1 requests:
exactly one value that is either empty or parseable as a valid host.
As defined in RFC 9112 Section 3.2:
"A client MUST send a Host header field (Section 7.2 of [HTTP]) in all HTTP/1.1 request messages.
If the target URI includes an authority component, then... | true |
Finset.Iic_product_Iic | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrderBot α]
[inst_3 : LocallyFiniteOrderBot β] [inst_4 : DecidableLE (α × β)] (a : α) (b : β),
Finset.Iic a ×ˢ Finset.Iic b = Finset.Iic (a, b) | null | true |
_private.Mathlib.Data.List.Pairwise.0.List.pairwise_iff_forall_infix._proof_1_50 | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} (l' : List α),
1 < l'.length →
∀ (l₁ l₂ : List α),
l₁.length + (l₁.length + (l₁.length + (l'.length - 1) - l₁.length) - l₁.length) < (l₁ ++ l' ++ l₂).length | null | false |
_private.Mathlib.Combinatorics.Matroid.Circuit.0.Matroid.IsCircuit.minimal_not_indep._simp_1_1 | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_2} {P : Set α → Prop} {s : Set α}, Minimal P s = (P s ∧ ∀ ⦃t : Set α⦄, t ⊂ s → ¬P t) | null | false |
CategoryTheory.Limits.idCofork._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} {X Y : C} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : Y ⟶ X},
f = g →
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.comp g (CategoryTheory.CategoryStruct.id X) | null | false |
BinaryTree.pairwiseNode.match_1 | Mathlib.Combinatorics.Enumerative.Catalan.Tree | ∀ (motive : BinaryTree Unit × BinaryTree Unit → Prop) (x : BinaryTree Unit × BinaryTree Unit),
(∀ (y₁ y₂ : BinaryTree Unit), motive (y₁, y₂)) → motive x | null | false |
AddCon.le_def | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {c d : AddCon M}, c ≤ d ↔ ∀ {x y : M}, c x y → d x y | Definition of `≤` for additive congruence relations. | true |
CategoryTheory.Limits.Fork.isLimitEquivOfIsos._auto_5 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | Lean.Syntax | null | false |
Std.WP.Spec.Iter.foldM_filterM | Std.WP.Triple.SpecLemmas | ∀ {α β δ : Type w} {n : Type w → Type w'} {o : Type w → Type w''} {Pred : Type uₚ} {EPred : Type uₑ}
[inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad n] [inst_3 : MonadAttach n] [LawfulMonad n]
[WeaklyLawfulMonadAttach n] [inst_6 : Monad o] [inst_7 : Std.WP.Assertion Pred] [inst_8 : Std.WP.A... | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.Rename.0.MvPowerSeries.rename._proof_2 | Mathlib.RingTheory.MvPowerSeries.Rename | ∀ {σ : Type u_1} {τ : Type u_3} {R : Type u_2} (f : σ → τ) [inst : Filter.TendstoCofinite f] [inst_1 : CommSemiring R]
(p q : MvPowerSeries σ R),
MvPowerSeries.renameFun f (p * q) = MvPowerSeries.renameFun f p * MvPowerSeries.renameFun f q | null | false |
PSet.toSet.eq_1 | Mathlib.SetTheory.ZFC.PSet | ∀ (u : PSet.{u}), u.toSet = {x | x ∈ u} | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore.0.SSet.Subcomplex.PairingCore.pairing._simp_8 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) | null | false |
Std.ExtTreeMap.inter.congr_simp | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t₁ t₁_1 : Std.ExtTreeMap α β cmp),
t₁ = t₁_1 → ∀ (t₂ t₂_1 : Std.ExtTreeMap α β cmp), t₂ = t₂_1 → t₁.inter t₂ = t₁_1.inter t₂_1 | null | true |
FiberPrebundle.toFiberBundle | Mathlib.Topology.FiberBundle.Basic | {B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_5} →
[inst : TopologicalSpace B] →
[inst_1 : TopologicalSpace F] →
[inst_2 : (x : B) → TopologicalSpace (E x)] → (a : FiberPrebundle F E) → FiberBundle F E | Make a `FiberBundle` from a `FiberPrebundle`. Concretely this means
that, given a `FiberPrebundle` structure for a sigma-type `E` -- which consists of a
number of "pretrivializations" identifying parts of `E` with product spaces `U × F` -- one
establishes that for the topology constructed on the sigma-type using
`Fibe... | true |
Lean.Lsp.SemanticTokenType.parameter.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokenType → Sort u} →
(t : Lean.Lsp.SemanticTokenType) → t.ctorIdx = 11 → motive Lean.Lsp.SemanticTokenType.parameter → motive t | null | false |
Convexity.StdSimplex.ext | Mathlib.Geometry.Convex.ConvexSpace.Defs | ∀ {X : Type u_2} {R : Type u} [inst : PartialOrder R] [inst_1 : Semiring R] {f g : Convexity.StdSimplex R X},
f.weights = g.weights → f = g | **Alias** of the forward direction of `Convexity.StdSimplex.weights_inj`. | true |
FP.Float.add._sparseCasesOn_3 | Mathlib.Data.FP.Basic | {motive : Bool → Sort u} → (t : Bool) → motive false → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.sle_iff_rotate_le_rotate._simp_1_22 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | null | false |
Lean.Meta.Grind.Entry.cases.injEq | Lean.Meta.Tactic.Grind.Extension | ∀ (declName : Lean.Name) (eager : Bool) (declName_1 : Lean.Name) (eager_1 : Bool),
(Lean.Meta.Grind.Entry.cases declName eager = Lean.Meta.Grind.Entry.cases declName_1 eager_1) =
(declName = declName_1 ∧ eager = eager_1) | null | true |
AddCommGrpCat.Colimits.Quot.desc._simp_3 | Mathlib.Algebra.Category.Grp.Colimits | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
Finset.max'_lt_iff | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty) {x : α}, s.max' H < x ↔ ∀ y ∈ s, y < x | null | true |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.xy_modEq_yn._simp_1_8 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {n a : ℕ}, (a ≡ 0 [MOD n]) = (n ∣ a) | null | false |
Lean.Elab.deprecatedSyntaxExt | Lean.Elab.DeprecatedSyntax | Lean.SimplePersistentEnvExtension Lean.Elab.SyntaxDeprecationEntry (Lean.NameMap Lean.Elab.SyntaxDeprecationEntry) | null | true |
CategoryTheory.Span.Hom | Mathlib.CategoryTheory.Bicategory.Span.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{Wₗ Wᵣ : CategoryTheory.MorphismProperty C} →
{c c' : C} → CategoryTheory.Span Wₗ Wᵣ c c' → CategoryTheory.Span Wₗ Wᵣ c c' → Type v_1 | A morphism of spans is a morphism between the apices compatible
with the projections. | true |
Std.ExtDHashMap.get_eq_getD | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {a : α}
{fallback : β a} {h : a ∈ m}, m.get a h = m.getD a fallback | null | true |
DirSupClosed.empty._simp_1 | Mathlib.Order.DirSupClosed | ∀ {α : Type u_1} [inst : Preorder α], DirSupClosed ∅ = True | null | false |
Finset.sum_Ico_int_sub | Mathlib.Algebra.BigOperators.Group.Finset.Interval | ∀ (b : ℕ) {α : Type u_1} [inst : AddCommGroup α] (f : ℤ → α),
∑ n ∈ Finset.Ico (-↑b) ↑b, (f n - f (n + 1)) = f (-↑b) - f ↑b | null | true |
SheafOfModules.instPreservesColimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} {C' : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} C']
{J' : CategoryTheory.GrothendieckTopology C'} {S : CategoryTheory.Sheaf J' RingCat}
(F : CategoryTheory.Functor... | null | true |
Lean.Grind.Ring.OfSemiring.neg._proof_1 | Init.Grind.Ring.Envelope | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (a b : α × α),
Lean.Grind.Ring.OfSemiring.r α a b →
(match a with
| (a, b) => Lean.Grind.Ring.OfSemiring.Q.mk (b, a)) =
match b with
| (a, b) => Lean.Grind.Ring.OfSemiring.Q.mk (b, a) | null | false |
LinearMap.IsReflective.dvd_two_mul | Mathlib.LinearAlgebra.RootSystem.OfBilinear | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{B : M →ₗ[R] M →ₗ[R] R} {x : M}, B.IsReflective x → ∀ (y : M), (B x) x ∣ 2 * (B x) y | null | true |
Rat.HeightOneSpectrum.natGenerator_dvd_iff | Mathlib.NumberTheory.Padics.HeightOneSpectrum | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : Algebra R ℚ] [inst_2 : IsIntegralClosure R ℤ ℚ]
(v : IsDedekindDomain.HeightOneSpectrum R) {n : ℕ},
Rat.HeightOneSpectrum.natGenerator v ∣ n ↔ ↑n ∈ Ideal.map (Rat.IsIntegralClosure.intEquiv R) v.asIdeal | null | true |
_private.Mathlib.Data.Nat.Factorization.Basic.0.Nat.Icc_factorization_eq_pow_dvd._simp_1_3 | Mathlib.Data.Nat.Factorization.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | null | false |
NonUnitalSubsemiring.map._proof_3 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(f : R →ₙ+* S) (s : NonUnitalSubsemiring R) {a b : S},
a ∈ (Subsemigroup.map (↑f) s.toSubsemigroup).carrier →
b ∈ (Subsemigroup.map (↑f) s.toSubsemigroup).carrier → a * b ∈ (Subsemigroup.map (↑f) s.toSubs... | null | false |
Lean.Meta.ParamInfo.binderInfo._default | Lean.Meta.Basic | Lean.BinderInfo | null | false |
TruncatedWittVector.commutes | Mathlib.RingTheory.WittVector.Compare | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ) {m : ℕ} (hm : n ≤ m),
(TruncatedWittVector.truncate hm).comp (TruncatedWittVector.zmodEquivTrunc p m).toRingHom =
(TruncatedWittVector.zmodEquivTrunc p n).toRingHom.comp (ZMod.castHom ⋯ (ZMod (p ^ n))) | The following diagram commutes:
```text
ZMod (p^n) ----------------------------> ZMod (p^m)
| |
| |
v v
TruncatedWittVector p n (ZMod p) ----> TruncatedWittV... | true |
Float.Model.UnpackedFloat.finite.sizeOf_spec | Init.Data.Float.Model.Unpacked.Basic | ∀ (sign : Float.Model.UnpackedFloat.Sign) (mantissa : ℕ) (exponent : ℤ) (mantissa_pos : 0 < mantissa),
sizeOf (Float.Model.UnpackedFloat.finite sign mantissa exponent mantissa_pos) =
1 + sizeOf sign + sizeOf mantissa + sizeOf exponent + sizeOf mantissa_pos | null | true |
Choose.choose_modEq_choose_mul_prod_range_choose._f | Mathlib.Data.Nat.Choose.Lucas | ∀ {n k p : ℕ} [Fact (Nat.Prime p)] (a : ℕ) (f : Nat.below a),
↑(n.choose k) ≡
↑((n / p ^ a).choose (k / p ^ a)) * ↑(∏ i ∈ Finset.range a, (n / p ^ i % p).choose (k / p ^ i % p)) [ZMOD ↑p] | null | false |
smul_eq_iff_eq_invOf_smul | Mathlib.Algebra.Group.Action.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : Monoid α] [inst_1 : MulAction α β] {c : α} {x y : β} [inst_2 : Invertible c],
c • x = y ↔ x = ⅟c • y | null | true |
ISize.add_neg_eq_sub | Init.Data.SInt.Lemmas | ∀ {a b : ISize}, a + -b = a - b | null | true |
CategoryTheory.CardinalFilteredPoset.coconeOfPredicateSet | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | {κ : Cardinal.{u}} →
[inst : Fact κ.IsRegular] →
{J : CategoryTheory.CardinalDirectedPoset κ} →
(P : Set ↑J.obj → Prop) →
[inst_1 : ∀ (S : Subtype P), CategoryTheory.IsCardinalFiltered (↑↑S) κ] →
CategoryTheory.Limits.Cocone (CategoryTheory.CardinalDirectedPoset.functorOfPredicateSet P) | **Alias** of `CategoryTheory.CardinalDirectedPoset.coconeOfPredicateSet`.
---
Given a predicate `P : Set J.obj → Prop` on the underlying type
of `J : CardinalDirectedPoset κ` such that all the subsets satisfying `P`
are `κ`-filtered, this is the cocone with point `J` given
by all the inclusions of the subsets satisfy... | true |
Std.Rxc.Iterator._sizeOf_1 | Init.Data.Range.Polymorphic.RangeIterator | {α : Type u} → [SizeOf α] → Std.Rxc.Iterator α → ℕ | null | false |
Lean.Meta.Structural.isInstMulNat | Lean.Meta.NatInstTesters | Lean.Expr → Lean.MetaM Bool | null | true |
ConvexOn.map_condExp_rnDeriv_le | Mathlib.InformationTheory.KullbackLeibler.DataProcessing | ∀ {𝓧 : Type u_1} {m m𝓧 : MeasurableSpace 𝓧} {μ ν : MeasureTheory.Measure 𝓧} [MeasureTheory.IsFiniteMeasure μ]
[MeasureTheory.IsFiniteMeasure ν] {f : ℝ → ℝ} (hm : m ≤ m𝓧),
MeasureTheory.StronglyMeasurable f →
ConvexOn ℝ (Set.Ici 0) f →
ContinuousWithinAt f (Set.Ici 0) 0 →
MeasureTheory.Integra... | null | true |
BitVec.toInt_srem | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (x y : BitVec w), (x.srem y).toInt = x.toInt.tmod y.toInt | null | true |
Option.length_toList_le | Init.Data.Option.List | ∀ {α : Type u_1} {o : Option α}, o.toList.length ≤ 1 | null | true |
PosNum.isOne | Mathlib.Data.Num.Basic | PosNum → Bool | Returns a Boolean for whether the `PosNum` is `one`. | true |
NonUnitalStarAlgHom.subsingleton | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : StarRing A]
[inst_3 : Module R A] [inst_4 : NonUnitalSemiring B] [inst_5 : StarRing B] [inst_6 : Module R B] [inst_7 : StarRing R]
[IsScalarTower R A A] [SMulCommClass R A A] [StarModule R A] [Subsingleton (Non... | null | true |
Set.biInter_gt_eq_iInf | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [NoMinOrder α] {s : α → Set β}, ⋂ n, ⋂ m, ⋂ (_ : m > n), s m = ⋂ n, s n | null | true |
_private.Mathlib.Basic.Rel.0.SetRel.dom_empty._proof_1_1 | Mathlib.Basic.Rel | ∀ {α : Type u_1} {β : Type u_2}, SetRel.dom ∅ = ∅ | null | false |
ProbabilityTheory.iInf_rat_gt_defaultRatCDF | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ (t : ℚ), ⨅ r, ProbabilityTheory.defaultRatCDF ↑r = ProbabilityTheory.defaultRatCDF t | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.