name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Algebra.Extension.cotangentComplex | Mathlib.RingTheory.Extension.Cotangent.Basic | {R : Type u} →
{S : Type v} →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → (P : Algebra.Extension R S) → P.Cotangent →ₗ[S] P.CotangentSpace | The cotangent complex given by a presentation `R[X] → S` (i.e. a closed embedding `S ↪ Aⁿ`). | true |
FaithfulSMul.of_injective | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M' : Type u_1} {X : Type u_5} [inst : SMul M' X] {Y : Type u_6} [inst_1 : SMul M' Y] {F : Type u_8}
[inst_2 : FunLike F X Y] [FaithfulSMul M' X] [MulActionHomClass F M' X Y] (f : F),
Function.Injective ⇑f → FaithfulSMul M' Y | null | true |
szemeredi_regularity | Mathlib.Combinatorics.SimpleGraph.Regularity.Lemma | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (G : SimpleGraph α) [inst_2 : DecidableRel G.Adj] {ε : ℝ}
{l : ℕ},
0 < ε →
l ≤ Fintype.card α →
∃ P, P.IsEquipartition ∧ l ≤ P.parts.card ∧ P.parts.card ≤ SzemerediRegularity.bound ε l ∧ P.IsUniform G ε | Effective **Szemerédi Regularity Lemma**: For any sufficiently large graph, there is an
`ε`-uniform equipartition of bounded size (where the bound does not depend on the graph). | true |
MonoidWithZeroHom.fst_apply_coe | Mathlib.Algebra.GroupWithZero.ProdHom | ∀ {G₀ : Type u_1} {H₀ : Type u_2} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero H₀] (x : G₀ˣ × H₀ˣ),
(MonoidWithZeroHom.fst G₀ H₀) ↑x = ↑x.1 | null | true |
DoubleCentralizer.natCast_toProd | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] (n : ℕ), (↑n).toProd = ↑n | null | true |
Vector.finIdxOf?_mk | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] {xs : Array α} (h : xs.size = n) (x : α),
(Vector.mk xs h).finIdxOf? x = Option.map (Fin.cast h) (xs.finIdxOf? x) | null | true |
Finset.toRight | Mathlib.Data.Finset.Sum | {α : Type u_1} → {β : Type u_2} → Finset (α ⊕ β) → Finset β | Given a finset of elements `α ⊕ β`, extract all the elements of the form `β`. This
forms a quasi-inverse to `disjSum`, in that it recovers its right input.
See also `List.partitionMap`.
| true |
CategoryTheory.Arrow.catCommSq | Mathlib.CategoryTheory.Comma.CatCommSq | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D₁ : Type u_3} →
{D₂ : Type u_4} →
[inst : CategoryTheory.Category.{u_5, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{u_6, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{u_7, u_3} D₁] →
[inst_3 : CategoryTheory.Category.{u_8, u... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.toList_insert_perm._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
CategoryTheory.ComposableArrows.Mk₁.map.eq_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X₀ X₁ : C} (f : X₀ ⟶ X₁) (isLt isLt_1 : 1 < 2)
(x_3 : ⟨1, isLt⟩ ≤ ⟨1, isLt_1⟩),
CategoryTheory.ComposableArrows.Mk₁.map f ⟨1, isLt⟩ ⟨1, isLt_1⟩ x_3 =
CategoryTheory.CategoryStruct.id (CategoryTheory.ComposableArrows.Mk₁.obj X₀ X₁ ⟨1, isLt⟩) | null | true |
AbsoluteValue.trivial._proof_3 | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {R : Type u_2} [inst : Semiring R] [inst_1 : DecidablePred fun x => x = 0] {S : Type u_1} [inst_2 : Semiring S]
[Nontrivial S] (x : R), (if x = 0 then 0 else 1) = 0 ↔ x = 0 | null | false |
HomologicalComplex.homology.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.Acyclic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K K_1 : HomologicalComplex C c) (e_K : K = K_1) (i i_1 : ι) (e_i : i = i_1)
[inst_2 : K.HasHomology i], K.homology i = K_1.homology i_1 | null | true |
DirectedOn.le_of_minimal | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {a b : α},
DirectedOn (fun x y => y ≤ x) s → Minimal (fun x => x ∈ s) a → b ∈ s → a ≤ b | null | true |
WittVector.instIsocrystalStandardOneDimIsocrystal._proof_2 | Mathlib.RingTheory.WittVector.Isocrystal | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (k : Type u_1) [inst_1 : CommRing k] [inst_2 : CharP k p]
[inst_3 : PerfectRing k p],
RingHomCompTriple (↑(WittVector.FractionRing.frobenius p k)) (RingHom.id (FractionRing (WittVector p k)))
↑(WittVector.FractionRing.frobenius p k) | null | false |
Sum.instLocallyFiniteOrder._proof_1 | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (a b x : α ⊕ β), x ∈ Finset.sumLift₂ Finset.Icc Finset.Icc a b ↔ a ≤ x ∧ x ≤ b | null | false |
CategoryTheory.HasInjectiveResolutions.mk._flat_ctor | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C],
(∀ (Z : C), CategoryTheory.HasInjectiveResolution Z) → CategoryTheory.HasInjectiveResolutions C | null | false |
CanonicallyOrderedAddCommMonoid.toAddCancelCommMonoid | Mathlib.Algebra.Order.Sub.Basic | (α : Type u_1) →
[inst : AddCommMonoid α] →
[inst_1 : PartialOrder α] → [inst_2 : Sub α] → [OrderedSub α] → [AddLeftReflectLE α] → AddCancelCommMonoid α | A `CanonicallyOrderedAddCommMonoid` with ordered subtraction and order-reflecting addition is
cancellative. This is not an instance as it would form a typeclass loop.
See note [reducible non-instances]. | true |
continuous_pow._f | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Monoid M] [ContinuousMul M] (x : ℕ) (f : Nat.below x),
Continuous fun a => a ^ x | null | false |
NumberField.ComplexEmbedding.LiesOver.mk | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {φ : L →+* ℂ} {ψ : K →+* ℂ},
φ.comp (algebraMap K L) = ψ → NumberField.ComplexEmbedding.LiesOver φ ψ | null | true |
Submodule.rank_sup_add_rank_inf_eq | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_1} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_1} R] (s t : Submodule R M),
Module.rank R ↥(s ⊔ t) + Module.rank R ↥(s ⊓ t) = Module.rank R ↥s + Module.rank R ↥t | null | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.shortCircuitPass.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit | (motive : Option (Array Lean.FVarId × Lean.MVarId) → Sort u_1) →
(result? : Option (Array Lean.FVarId × Lean.MVarId)) →
((fst : Array Lean.FVarId) → (newGoal : Lean.MVarId) → motive (some (fst, newGoal))) →
((x : Option (Array Lean.FVarId × Lean.MVarId)) → motive x) → motive result? | null | false |
comp_partialSups | Mathlib.Order.PartialSups | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β]
[inst_2 : Preorder ι] [inst_3 : LocallyFiniteOrderBot ι] {F : Type u_4} [inst_4 : FunLike F α β] [SupHomClass F α β]
(f : ι → α) (g : F), ⇑(partialSups (⇑g ∘ f)) = ⇑g ∘ ⇑(partialSups f) | null | true |
Nat.isSome_getElem?_toArray_ric_eq | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i : ℕ}, ((*...=n).toArray[i]?.isSome = true) = (i ≤ n) | null | true |
Module.End.UnifEigenvalues.val | Mathlib.LinearAlgebra.Eigenspace.Basic | {R : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (f : Module.End R M) → (k : ℕ∞) → f.UnifEigenvalues k → R | The underlying value of a bundled eigenvalue. | true |
CategoryTheory.GradedObject.mapBifunctorLeftUnitor_naturality | Mathlib.CategoryTheory.GradedObject.Unitor | ∀ {C : Type u_1} {D : Type u_2} {I : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : Zero I] [inst_3 : DecidableEq I]
[inst_4 : CategoryTheory.Limits.HasInitial C] (F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) (X : C)
(... | null | true |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.thickening_eq_empty_iff._simp_1_1 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {ε : ℝ} {s : Set α}, 0 < ε → (Metric.thickening ε s = ∅) = (s = ∅) | null | false |
Finset.addConst_neg_left | Mathlib.Combinatorics.Additive.DoublingConst | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : DecidableEq G] (A B : Finset G), (-A).addConst B = A.subConst B | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer.0.CategoryTheory.Limits.WalkingMulticospan.instFinCategoryOfLOfDecidableEqR._simp_4 | Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer | ∀ {α : Type u_1} {a : α} {s : Multiset α}, (a ::ₘ s).Nodup = (a ∉ s ∧ s.Nodup) | null | false |
CategoryTheory.MorphismProperty.Over.pullbackMapHomPullback._proof_7 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {P : CategoryTheory.MorphismProperty T} {Y Z : T}
(g : Y ⟶ Z) [CategoryTheory.Limits.HasPullbacks T], P.HasPullbacksAlong g | null | false |
Congr!.Config._sizeOf_1 | Mathlib.Tactic.CongrExclamation | Congr!.Config → ℕ | null | false |
Lean.Meta.Grind.Order.Struct.mk.noConfusion | Lean.Meta.Tactic.Grind.Order.Types | {P : Sort u} →
{id : ℕ} →
{type : Lean.Expr} →
{u : Lean.Level} →
{isPreorderInst leInst : Lean.Expr} →
{ltInst? isPartialInst? isLinearPreInst? lawfulOrderLTInst? : Option Lean.Expr} →
{ringId? : Option ℕ} →
{isCommRing : Bool} →
{ringInst? ordere... | null | false |
Std.DHashMap.Internal.Raw₀.toList_map | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} (m : Std.DHashMap.Internal.Raw₀ α β) {f : (a : α) → β a → γ a},
(↑(Std.DHashMap.Internal.Raw₀.map f m)).toList.Perm (List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) (↑m).toList) | null | true |
Turing.TM2to1.StAct.rec | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} →
{motive : Turing.TM2to1.StAct K Γ σ k → Sort u} →
((a : σ → Γ k) → motive (Turing.TM2to1.StAct.push a)) →
((a : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StAct.peek a)) →
((a : σ → Option (Γ k) →... | null | false |
Function.Injective.leftCancelMonoid | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Mul M₁] →
[inst_1 : One M₁] →
[inst_2 : Pow M₁ ℕ] →
[inst_3 : LeftCancelMonoid M₂] →
(f : M₁ → M₂) →
Function.Injective f →
f 1 = 1 →
(∀ (x y : M₁), f (x * y) = f x * f y) →
... | A type endowed with `1` and `*` is a left cancel monoid, if it admits an injective map that
preserves `1` and `*` to a left cancel monoid. See note [reducible non-instances]. | true |
CategoryTheory.Functor.CoconeTypes.IsColimit.fac_apply | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} {c : F.CoconeTypes}
(hc : c.IsColimit) (c' : F.CoconeTypes) (j : J) (x : F.obj j), hc.desc c' (c.ι j x) = c'.ι j x | null | true |
Lean.Parser.doElemParser | Lean.Parser.Do | optParam ℕ 0 → Lean.Parser.Parser | null | true |
Std.DTreeMap.Internal.Impl.toList_filter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {f : (a : α) → β a → Bool},
t.WF → (Std.DTreeMap.Internal.Impl.filter! f t).toList = List.filter (fun p => f p.fst p.snd) t.toList | null | true |
HasDerivAt.comp_sub_const | Mathlib.Analysis.Calculus.Deriv.Shift | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} (x a : 𝕜),
HasDerivAt f f' (x - a) → HasDerivAt (fun x => f (x - a)) f' x | Translation in the domain does not change the derivative. | true |
CategoryTheory.AddMonObj.zero_associator | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M N P : C}
[inst_2 : CategoryTheory.AddMonObj M] [inst_3 : CategoryTheory.AddMonObj N] [inst_4 : CategoryTheory.AddMonObj P],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
... | null | true |
_private.Mathlib.MeasureTheory.Measure.Prokhorov.0.MeasureTheory.exists_measure_iUnion_gt_of_isCompact_closure._simp_1_5 | Mathlib.MeasureTheory.Measure.Prokhorov | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (ν : MeasureTheory.ProbabilityMeasure Ω) (s : Set Ω), ↑ν s = ↑(ν s) | null | false |
Equiv.sumArrowEquivProdArrow._proof_1 | Mathlib.Logic.Equiv.Prod | ∀ (α : Type u_3) (β : Type u_1) (γ : Type u_2) (f : α ⊕ β → γ),
(fun p => Sum.elim p.1 p.2) ((fun f => (f ∘ Sum.inl, f ∘ Sum.inr)) f) = f | null | false |
Module.Baer.ExtensionOfMaxAdjoin.ideal._proof_1 | Mathlib.Algebra.Module.Injective | ∀ {R : Type u_1} [inst : Ring R] {N : Type u_2} [inst_1 : AddCommGroup N] [inst_2 : Module R N], IsScalarTower R R N | null | false |
NumberField.logHeight₁_eq | Mathlib.NumberTheory.Height.NumberField | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : K),
Height.logHeight₁ x = ∑ v, ↑v.mult * (v x).posLog + ∑ᶠ (v : NumberField.FinitePlace K), (v x).posLog | This is the familiar definition of the logarithmic height on a number field. | true |
Aesop.RuleApplication.successProbability? | Aesop.RuleTac.Basic | Aesop.RuleApplication → Option Aesop.Percent | null | true |
Aesop.Script.StepTree.toMessageData | Aesop.Script.UScriptToSScript | Aesop.Script.StepTree → Lean.MessageData | null | true |
Nat.range_succ_eq_Iic | Mathlib.Order.Interval.Finset.Nat | ∀ (n : ℕ), Finset.range (n + 1) = Finset.Iic n | null | true |
_private.Mathlib.Algebra.Group.Submonoid.Operations.0.AddSubmonoid.map_id.match_1_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : AddZeroClass M] (S : AddSubmonoid M) (x : M)
(motive : x ∈ AddSubmonoid.map (AddMonoidHom.id M) S → Prop) (x_1 : x ∈ AddSubmonoid.map (AddMonoidHom.id M) S),
(∀ (h : x ∈ ↑S), motive ⋯) → motive x_1 | null | false |
Lean.Elab.Structural.IndGroupInst.toMessageData | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInst → Lean.MessageData | null | true |
List.all_one_of_le_one_le_of_prod_eq_one | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {M : Type u_3} [inst : CommMonoid M] [inst_1 : PartialOrder M] [IsOrderedMonoid M] {l : List M},
(∀ x ∈ l, 1 ≤ x) → l.prod = 1 → ∀ {x : M}, x ∈ l → x = 1 | null | true |
ClopenUpperSet.noConfusion | Mathlib.Topology.Sets.Order | {P : Sort u} →
{α : Type u_2} →
{inst : TopologicalSpace α} →
{inst_1 : LE α} →
{t : ClopenUpperSet α} →
{α' : Type u_2} →
{inst' : TopologicalSpace α'} →
{inst'_1 : LE α'} →
{t' : ClopenUpperSet α'} →
α = α' → inst ≍ inst' → inst... | null | false |
_private.Mathlib.Algebra.FiniteSupport.Basic.0.Function.HasFiniteMulSupport.pi._simp_1_1 | Mathlib.Algebra.FiniteSupport.Basic | ∀ {ι : Type u_1} {M : Type u_3} [inst : One M] {f : ι → M} {x : ι}, (x ∈ Function.mulSupport f) = (f x ≠ 1) | null | false |
MeasureTheory.VectorMeasure.enorm_integral_le_lintegral_enorm | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G]
[inst_5 : NormedSpace ℝ G] {f : X → E} {μ : MeasureTheory.VectorMeasure X F} {B :... | null | true |
IsFiniteLength.of_subsingleton._simp_1 | Mathlib.RingTheory.FiniteLength | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Subsingleton M],
IsFiniteLength R M = True | null | false |
Urysohns.CU.approx.match_1 | Mathlib.Topology.UrysohnsLemma | {X : Type u_1} →
[inst : TopologicalSpace X] →
{P : Set X → Set X → Prop} →
(motive : ℕ → Urysohns.CU P → X → Sort u_2) →
(x : ℕ) →
(x_1 : Urysohns.CU P) →
(x_2 : X) →
((c : Urysohns.CU P) → (x : X) → motive 0 c x) →
((n : ℕ) → (c : Urysohns.CU P) ... | null | false |
MeasureTheory.Measure.MutuallySingular.zero_left | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, MeasureTheory.Measure.MutuallySingular 0 μ | null | true |
Module.Basis.extendLe_subset | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s t : Set V}
(hs : LinearIndepOn K id s) (hst : s ⊆ t) (ht : ⊤ ≤ Submodule.span K t),
Set.range ⇑(Module.Basis.extendLe hs hst ht) ⊆ t | null | true |
CategoryTheory.PreOneHypercover.isoMk_inv_s₀ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S}
(s₀ : E.I₀ ≃ F.I₀) (h₀ : (i : E.I₀) → E.X i ≅ F.X (s₀ i)) (s₁ : ⦃i j : E.I₀⦄ → E.I₁ i j ≃ F.I₁ (s₀ i) (s₀ j))
(h₁ : ⦃i j : E.I₀⦄ → (k : E.I₁ i j) → E.Y k ≅ F.Y (s₁ k))
(w₀ :
autoParam (∀ (i : E.I₀), Cate... | null | true |
Lean.HeadIndex.lam.sizeOf_spec | Lean.HeadIndex | sizeOf Lean.HeadIndex.lam = 1 | null | true |
_private.Mathlib.Analysis.Normed.Group.Basic.0.nontrivialTopology_iff_exists_nnnorm_ne_zero'._simp_1_2 | Mathlib.Analysis.Normed.Group.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α}, Inseparable x y = (nndist x y = 0) | null | false |
CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.SingleObj | ∀ {M : Type u_1} [inst : Monoid M] (J : CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u_2))
(p : ↑(MulAction.fixedPoints M (J.obj (CategoryTheory.SingleObj.star M)))) {j j' : CategoryTheory.SingleObj M},
↑p ∈ MulAction.fixedPoints M (J.obj (CategoryTheory.SingleObj.star M)) | null | false |
LinearIsometryEquiv.conjStarAlgEquiv._proof_2 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_2} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H],
SMulCommClass 𝕜 𝕜 H | null | false |
Std.Internal.List.minKey?_eq_some_minKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)} {he : l.isEmpty = false},
Std.Internal.List.minKey? l = some (Std.Internal.List.minKey l he) | null | true |
Lean.Elab.Tactic.Do.ProofMode.elabMExact | Lean.Elab.Tactic.Do.ProofMode.Exact | Lean.Elab.Tactic.Tactic | null | true |
_private.Mathlib.Probability.Kernel.Composition.MeasureCompProd.0.MeasureTheory.Measure.absolutelyContinuous_of_compProd._simp_1_1 | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (μ Set.univ = 0) = (μ = 0) | null | false |
IsOrderedVAdd.vadd_le_vadd_right | Mathlib.Algebra.Order.AddTorsor | ∀ {G : Type u_3} {P : Type u_4} {inst : LE G} {inst_1 : LE P} {inst_2 : VAdd G P} [self : IsOrderedVAdd G P] (c d : G),
c ≤ d → ∀ (a : P), c +ᵥ a ≤ d +ᵥ a | null | true |
_private.Mathlib.RingTheory.LaurentSeries.0.LaurentSeries.coe_range_dense._simp_1_2 | Mathlib.RingTheory.LaurentSeries | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
_private.Mathlib.RingTheory.DedekindDomain.Different.0.FractionalIdeal.trace_mem_dual_one._simp_1_2 | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {K : Type u_2} {L : Type u} {B : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : CommRing B]
[inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : Algebra A B] [inst_7 : Algebra K L]
[inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : IsScalarTower A B L... | null | false |
Std.IteratorLoop.WithWF.mk._flat_ctor | Init.Data.Iterators.Consumers.Monadic.Loop | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
[inst : Std.Iterator α m β] →
{γ : Type x} →
{PlausibleForInStep : β → γ → ForInStep γ → Prop} →
{hwf : Std.IteratorLoop.WellFounded α m PlausibleForInStep} →
Std.IterM m β → γ → Std.IteratorLoop.WithWF α m Pl... | null | false |
RelIso.eq_iff_eq | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≃r s) {a b : α}, f a = f b ↔ a = b | null | true |
CStarModule.innerₛₗ._proof_4 | Mathlib.Analysis.CStarAlgebra.Module.Defs | ∀ {A : Type u_1} {E : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : AddCommGroup E]
[inst_3 : Module ℂ A] [inst_4 : Module ℂ E] [inst_5 : PartialOrder A] [inst_6 : SMul A E] [inst_7 : Norm A]
[inst_8 : Norm E] [inst_9 : CStarModule A E] [StarModule ℂ A] (z : ℂ) (y : E),
{ toFun := fun y_1 => ... | null | false |
Qq.instBEqQuoted._aux_1 | Qq.Typ | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | null | false |
Fin.insertNth_sub | Mathlib.Algebra.Group.Fin.Tuple | ∀ {n : ℕ} {α : Fin (n + 1) → Type u_1} [inst : (j : Fin (n + 1)) → Sub (α j)] (i : Fin (n + 1)) (x y : α i)
(p q : (j : Fin n) → α (i.succAbove j)), i.insertNth (x - y) (p - q) = i.insertNth x p - i.insertNth y q | null | true |
Lean.Compiler.LCNF.instantiateRangeArgs | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Expr → ℕ → ℕ → Array (Lean.Compiler.LCNF.Arg pu) → Lean.Expr | null | true |
SpectrumRestricts.starAlgHom_injective | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Semifield S] [inst_6 : StarRing S]
[inst_7 : MetricSpace S] [inst_8 : IsTopologicalSemiring S] [inst_9 : ContinuousStar S] [inst... | null | true |
Quaternion.imK_ratCast | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] (q : ℚ), (↑q).imK = 0 | null | true |
AddCircle.homeomorphAddCircle_symm_apply_mk | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] (p q : 𝕜) [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
[inst_3 : TopologicalSpace 𝕜] [inst_4 : OrderTopology 𝕜] (hp : p ≠ 0) (hq : q ≠ 0) (x : 𝕜),
(AddCircle.homeomorphAddCircle p q hp hq).symm ↑x = ↑(x * (q⁻¹ * p)) | null | true |
ZeroAtInftyContinuousMap.coe_zero | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β], ⇑0 = 0 | null | true |
_private.Init.Grind.Module.Envelope.0.Lean.Grind.IntModule.OfNatModule.rel | Init.Grind.Module.Envelope | {α : Type u} →
[inst : Lean.Grind.NatModule α] →
Equivalence (Lean.Grind.IntModule.OfNatModule.r α) →
Lean.Grind.IntModule.OfNatModule.Q α → Lean.Grind.IntModule.OfNatModule.Q α → Prop | null | true |
_private.Mathlib.RingTheory.Flat.EquationalCriterion.0.Module.Flat.projective_of_finitePresentation.match_1_1 | Mathlib.RingTheory.Flat.EquationalCriterion | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ k h₂ h₃, LinearMap.id = h₃ ∘ₗ h₂) → Prop) (x : ∃ k h₂ h₃, LinearMap.id = h₃ ∘ₗ h₂),
(∀ (w : ℕ) (f : M →ₗ[R] Fin w →₀ R) (g : (Fin w →₀ R) →ₗ[R] M) (eq : LinearMap.id = g ∘ₗ f), motive ⋯) → motive x | null | false |
Module.finitePresentation_iff_finite | Mathlib.Algebra.Module.FinitePresentation | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsNoetherianRing R],
Module.FinitePresentation R M ↔ Module.Finite R M | null | true |
_private.Qq.AssertInstancesCommute.0.Qq.Impl._aux_Qq_AssertInstancesCommute___elabRules_Qq_Impl_termAssertInstancesCommuteImpl__1.match_1 | Qq.AssertInstancesCommute | (motive :
Option (Lean.FVarId × (u : Q(Lean.Level)) × (ty : Q(Q(Sort «$u»))) × Q(Q(«$$ty»)) × Q(Q(«$$ty»))) → Sort u_1) →
(__do_lift : Option (Lean.FVarId × (u : Q(Lean.Level)) × (ty : Q(Q(Sort «$u»))) × Q(Q(«$$ty»)) × Q(Q(«$$ty»)))) →
((fvar : Lean.FVarId) →
(fst : Q(Lean.Level)) →
(fst_1 :... | null | false |
_private.Mathlib.Topology.DiscreteSubset.0.mem_codiscreteWithin._simp_1_5 | Mathlib.Topology.DiscreteSubset | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | null | false |
AddMonoidAlgebra.ofMagma_apply | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ (R : Type u_8) (M : Type u_9) [inst : Semiring R] [inst_1 : Add M] (a : Multiplicative M),
(AddMonoidAlgebra.ofMagma R M) a = AddMonoidAlgebra.single (Multiplicative.toAdd a) 1 | null | true |
OrderAddMonoidHom.fst_apply | Mathlib.Algebra.Order.Monoid.Lex | ∀ (α : Type u_1) (β : Type u_2) [inst : AddMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddMonoid β]
[inst_3 : Preorder β] (self : α × β), (OrderAddMonoidHom.fst α β) self = self.1 | null | true |
QuotientAddGroup.homQuotientZSMulOfHom_comp | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {A B : Type u} [inst : AddCommGroup A] [inst_1 : AddCommGroup B] (f : A →+ B) (g : B →+ A) (n : ℤ),
QuotientAddGroup.homQuotientZSMulOfHom (f.comp g) n =
(QuotientAddGroup.homQuotientZSMulOfHom f n).comp (QuotientAddGroup.homQuotientZSMulOfHom g n) | null | true |
FilterBasis | Mathlib.Order.Filter.Bases.Basic | Type u_6 → Type u_6 | A filter basis `B` on a type `α` is a nonempty collection of sets of `α`
such that the intersection of two elements of this collection contains some element
of the collection. | true |
CategoryTheory.yonedaJointlyReflectsLimits._proof_1 | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] (F : CategoryTheory.Functor J Cᵒᵖ) (c : CategoryTheory.Limits.Cone F)
(hc : (X : C) → CategoryTheory.Limits.IsLimit ((CategoryTheory.yoneda.obj X).mapCone c))
(s : CategoryTheory.Limits.Co... | null | false |
List.le_max_of_mem | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Max α] [inst_1 : LE α] [Std.IsLinearOrder α] [Std.LawfulOrderMax α] {l : List α} {a : α}
(ha : a ∈ l), a ≤ l.max ⋯ | null | true |
CategoryTheory.Limits.createsLimitsOfShapeOfCreatesEqualizersAndProducts._proof_3 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
{K : CategoryTheory.Functor J C},
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete J) C →
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p... | null | false |
CommAlgCat.algEquivOfIso_apply | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {A B : CommAlgCat R} (i : A ≅ B) (a : ↑A),
(CommAlgCat.algEquivOfIso i) a = (CategoryTheory.ConcreteCategory.hom i.hom) a | null | true |
bind_pure_unit | Init.Control.Lawful.Basic | ∀ {m : Type u_1 → Type u_2} [inst : Monad m] [LawfulMonad m] {x : m PUnit.{u_1 + 1}},
(do
x
pure PUnit.unit) =
x | null | true |
Aesop.TreeRef.rec | Aesop.Tree.Traversal | {motive : Aesop.TreeRef → Sort u} →
((gref : Aesop.GoalRef) → motive (Aesop.TreeRef.goal gref)) →
((rref : Aesop.RappRef) → motive (Aesop.TreeRef.rapp rref)) →
((cref : Aesop.MVarClusterRef) → motive (Aesop.TreeRef.mvarCluster cref)) → (t : Aesop.TreeRef) → motive t | null | false |
rank_eq_card_basis | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
{ι : Type w} [inst_4 : Fintype ι] (h : Module.Basis ι R M), Module.rank R M = ↑(Fintype.card ι) | If a vector space has a finite basis, then its dimension (seen as a cardinal) is equal to the
cardinality of the basis. | true |
div_ne_one | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, a / b ≠ 1 ↔ a ≠ b | null | true |
MultilinearMap.currySum._proof_7 | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type u_5} {ι : Type u_2} {ι' : Type u_1} {M₂ : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : Module R M₂] {N : ι ⊕ ι' → Type u_4} [inst_3 : (i : ι ⊕ ι') → AddCommMonoid (N i)]
[inst_4 : (i : ι ⊕ ι') → Module R (N i)] (f : MultilinearMap R N M₂) [inst_5 : DecidableEq ι]
(u : (i : ι... | null | false |
CategoryTheory.Mod.Hom.mk'._auto_1 | Mathlib.CategoryTheory.Monoidal.Mod | Lean.Syntax | null | false |
ENat.instUniqueUnits | Mathlib.Data.ENat.Basic | Unique ℕ∞ˣ | null | true |
ContinuousMultilinearMap.linearDeriv.congr_simp | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
(f f_1 : ContinuousMultili... | null | true |
Subsemigroup.op._proof_1 | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_1} [inst : Mul M] (x : Subsemigroup M) {a b : Mᵐᵒᵖ},
a ∈ MulOpposite.unop ⁻¹' ↑x → b ∈ MulOpposite.unop ⁻¹' ↑x → MulOpposite.unop b * MulOpposite.unop a ∈ x | null | false |
MeasureTheory.measurePreserving_pi_empty | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u} {α : ι → Type v} [inst : Fintype ι] [inst_1 : IsEmpty ι] {m : (i : ι) → MeasurableSpace (α i)}
(μ : (i : ι) → MeasureTheory.Measure (α i)),
MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.ofUniqueOfUnique ((i : ι) → α i) Unit))
(MeasureTheory.Measure.pi μ) (MeasureTheory.Measure.dirac ()) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.