name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MulHom.mk.inj | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} {N : Type u_11} {inst : Mul M} {inst_1 : Mul N} {toFun : M → N}
{map_mul' : ∀ (x y : M), toFun (x * y) = toFun x * toFun y} {toFun_1 : M → N}
{map_mul'_1 : ∀ (x y : M), toFun_1 (x * y) = toFun_1 x * toFun_1 y},
{ toFun := toFun, map_mul' := map_mul' } = { toFun := toFun_1, map_mul' := map_mul'_1... | null | true |
_private.Mathlib.Tactic.Tauto.0.initFn._@.Mathlib.Tactic.Tauto.2865712539._hygCtx._hyg.4 | Mathlib.Tactic.Tauto | IO (Lean.Option Bool) | null | false |
UpperHalfPlane.instIsFiniteMeasureOnCompactsComapComplexCoeVolume | Mathlib.Analysis.Complex.UpperHalfPlane.Measure | MeasureTheory.IsFiniteMeasureOnCompacts (MeasureTheory.Measure.comap UpperHalfPlane.coe MeasureTheory.volume) | null | true |
CategoryTheory.ObjectProperty.extensionProduct_isoClosure_left | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P Q : Categor... | null | true |
MeasureTheory.AEStronglyMeasurable.pow | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} [inst_1 : Monoid β] [ContinuousMul β],
MeasureTheory.AEStronglyMeasurable f μ → ∀ (n : ℕ), MeasureTheory.AEStronglyMeasurable (f ^ n) μ | null | true |
_private.Mathlib.Algebra.Group.Int.Even.0.Int.even_iff._simp_1_3 | Mathlib.Algebra.Group.Int.Even | ∀ (n : ℤ), n + n = 2 * n | null | false |
ProbabilityTheory.setIntegral_compProd_univ_left | Mathlib.Probability.Kernel.Composition.IntegralCompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} [inst : NormedAddCommGroup E] {a : α} {κ : ProbabilityTheory.Kernel α β}
[ProbabilityTheory.IsSFiniteKernel κ] {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFinit... | null | true |
AffineSubspace.direction_eq_self_iff_zero_mem | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
{s : AffineSubspace k V}, ↑s.direction = s ↔ 0 ∈ s | An affine subspace contains zero if and only if it equals its directions. | true |
DFinsupp.le_iff' | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : DecidableEq ι] [inst_4 : (i : ι) → (x : α i) → Decidable (x ≠ 0)]
{f g : Π₀ (i : ι), α i} {s : Finset ι}, f.support ⊆ s → (f ≤ g ↔ ∀ i ∈ s, f i ≤ g i) | null | true |
DirectSum.coeAlgHom._proof_2 | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_3} {S : Type u_2} {R : Type u_1} [inst : AddMonoid ι] [inst_1 : CommSemiring S] [inst_2 : Semiring R]
[inst_3 : Algebra S R] (A : ι → Submodule S R) [inst_4 : SetLike.GradedMonoid A] {i j : ι} (x : ↥(A i))
(x_1 : ↥(A j)), (A (i + j)).subtype (GradedMonoid.GMul.mul x x_1) = (A (i + j)).subtype (GradedM... | null | false |
_private.Mathlib.GroupTheory.CosetCover.0.Subgroup.leftCoset_cover_filter_FiniteIndex_aux.match_1_3 | Mathlib.GroupTheory.CosetCover | ∀ {G : Type u_1} [inst : Group G] {ι : Type u_2} {H : ι → Subgroup G} {s : Finset ι}
(t : (i : ι) → i ∈ s → (H i).FiniteIndex → Finset ↥(H i)) (j : ι) (hj : j ∈ s) (hjfi : (H j).FiniteIndex)
(motive : (t j hj hjfi).Nonempty → Prop) (x : (t j hj hjfi).Nonempty),
(∀ (x : ↥(H j)) (hx : x ∈ t j hj hjfi), motive ⋯) → ... | null | false |
Matrix.BlockTriangular.det_fintype | Mathlib.LinearAlgebra.Matrix.Block | ∀ {α : Type u_1} {m : Type u_2} {R : Type v} {M : Matrix m m R} {b : m → α} [inst : CommRing R] [inst_1 : DecidableEq m]
[inst_2 : Fintype m] [inst_3 : DecidableEq α] [inst_4 : Fintype α] [inst_5 : LinearOrder α],
M.BlockTriangular b → M.det = ∏ k, (M.toSquareBlock b k).det | null | true |
SaturatedAddSubmonoid.sSup_def | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {f : Set (SaturatedAddSubmonoid M)},
sSup f = (sSup (SaturatedAddSubmonoid.toAddSubmonoid '' f)).saturation | null | true |
Measurable.dite_const | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {p : Prop} [inst : Decidable p]
{f : p → α → β} {g : ¬p → α → β},
(∀ (h : p), Measurable (f h)) → (∀ (h : ¬p), Measurable (g h)) → Measurable (dite p f g) | null | true |
Subgroup.map | Mathlib.Algebra.Group.Subgroup.Map | {G : Type u_1} → [inst : Group G] → {N : Type u_4} → [inst_1 : Group N] → (G →* N) → Subgroup G → Subgroup N | The image of a subgroup along a monoid homomorphism is a subgroup. | true |
FractionalIdeal.mem_coeIdeal_of_mem | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{x : R} {I : Ideal R}, x ∈ I → (algebraMap R P) x ∈ ↑I | null | true |
Module.annihilator_finsupp | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_4}
[Nonempty ι], Module.annihilator R (ι →₀ M) = Module.annihilator R M | null | true |
Int.mul_neg_of_pos_of_neg | Init.Data.Int.Order | ∀ {a b : ℤ}, 0 < a → b < 0 → a * b < 0 | null | true |
CategoryTheory.Limits.Multifork.toPiFork_π_app_one | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
{I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I)
{c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right}
(hd :... | null | true |
CategoryTheory.yonedaMon_naturality | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N X Y : C} [inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N]
(α : CategoryTheory.yonedaMonObj M ⟶ CategoryTheory.yonedaMonObj N) (f : X ⟶ Y) (g : Y ⟶ M),
(CategoryTheory.Concre... | null | true |
CircularPreorder.mk._flat_ctor | Mathlib.Order.Circular | {α : Type u_1} →
(btw sbtw : α → α → α → Prop) →
(∀ (a : α), btw a a a) →
(∀ {a b c : α}, btw a b c → btw b c a) →
autoParam (∀ {a b c : α}, sbtw a b c ↔ btw a b c ∧ ¬btw c b a)
CircularPreorder.sbtw_iff_btw_not_btw._autoParam →
(∀ {a b c d : α}, sbtw a b c → sbtw b d c → sbtw ... | null | false |
CategoryTheory.Limits.preservesFiniteColimits_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]
(F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.Limits.PreservesFiniteLimits F],
CategoryTheory.Limits.PreservesFiniteColimits F.leftOp | If `F : C ⥤ Dᵒᵖ` preserves finite limits, then `F.leftOp : Cᵒᵖ ⥤ D` preserves finite
colimits. | true |
fintypeToFinBoolAlgOp._proof_7 | Mathlib.Order.Category.FinBoolAlg | ∀ {X Y : FintypeCat} (f : X ⟶ Y), (CompleteLatticeHom.setPreimage ⇑(CategoryTheory.ConcreteCategory.hom f)) ⊤ = ⊤ | null | false |
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.Split.generalizeMatchDiscrs.mkNewTarget | Lean.Meta.Tactic.Split | Lean.Name →
Array Lean.Expr →
Lean.Meta.MatcherInfo → ℕ → Array Lean.Expr → Array Lean.Expr → IO.Ref Bool → Lean.Expr → Lean.MetaM Lean.Expr | null | true |
MaxTropical.instOrderBot.eq_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LE R] [inst_1 : OrderBot R],
MaxTropical.instOrderBot = { toBot := MaxTropical.instBot, bot_le := ⋯ } | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.isPath_iff_isSubwalk_imp_nil._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (i j : ℕ),
((p.take j).drop i).Nil → G.Walk ((p.take j).getVert i) (p.getVert j) = G.Walk (p.getVert j) (p.getVert j) | null | false |
Std.DTreeMap.Const.get?_ofList_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} [Std.TransCmp cmp] {l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
∀ {v : β},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
(k, v) ∈ l → Std.DTreeMap.Const.get? (Std.DTreeMap.Const.ofList l cmp) k' = some v | null | true |
_private.Init.Grind.Module.Envelope.0.Lean.Grind.IntModule.OfNatModule.r.match_1.splitter | Init.Grind.Module.Envelope | (α : Type u_1) →
(motive : α × α → α × α → Sort u_2) → (x x_1 : α × α) → ((a b c d : α) → motive (a, b) (c, d)) → motive x x_1 | null | true |
WittVector.inverseCoeff.congr_simp | Mathlib.RingTheory.WittVector.DiscreteValuationRing | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {k : Type u_1} [inst : CommRing k] [inst_1 : CharP k p] (a a_1 : kˣ),
a = a_1 →
∀ (A A_1 : WittVector p k),
A = A_1 → ∀ (a_2 a_3 : ℕ), a_2 = a_3 → WittVector.inverseCoeff a A a_2 = WittVector.inverseCoeff a_1 A_1 a_3 | null | true |
Stream'.Seq.get?_cons_succ | Mathlib.Data.Seq.Defs | ∀ {α : Type u} (a : α) (s : Stream'.Seq α) (n : ℕ), (Stream'.Seq.cons a s).get? (n + 1) = s.get? n | null | true |
multilinearCurryLeftEquiv_symm_apply | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ (R : Type uR) {n : ℕ} (M : Fin n.succ → Type v) (M₂ : Type v₂) [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂]
(f : M 0 →ₗ[R] MultilinearMap R (fun i => M i.succ) M₂), (multilinearCurryLeftE... | null | true |
_private.Mathlib.MeasureTheory.OuterMeasure.AE.0.MeasureTheory.union_ae_eq_right._simp_1_1 | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u} {s t : Set α} {l : Filter α}, (s =ᶠ[l] t) = (s ≤ᶠ[l] t ∧ t ≤ᶠ[l] s) | null | false |
Std.DTreeMap.Internal.Impl.toArray_filterMap! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {γ : α → Type w}
{f : (a : α) → β a → Option (γ a)},
t.WF →
(Std.DTreeMap.Internal.Impl.filterMap! f t).toArray =
Array.filterMap (fun p => Option.map (fun x => ⟨p.fst, x⟩) (f p.fst p.snd)) t.toArray | null | true |
CategoryTheory.WithInitial.ofCommaObject._proof_1 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D]
(c : CategoryTheory.Comma (CategoryTheory.Functor.const C) (CategoryTheory.Functor.id (CategoryTheory.Functor C D)))
(x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (c.hom.app x)... | null | false |
CategoryTheory.Limits.asEmptyCone._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C) ⦃X_1 Y : CategoryTheory.Discrete PEmpty.{1}⦄
(f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const (CategoryTheory.Discrete PEmpty.{1})).obj X).map f)
(id (CategoryTheory.Discrete.casesOn Y fun as => ⋯.elim)) =
... | null | false |
lowerClosure_mul_distrib | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (s t : Set α),
lowerClosure (s * t) = lowerClosure s * lowerClosure t | null | true |
CategoryTheory.Oplax.StrongTrans.Modification.equivOplax_apply | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G}
(Γ : (CategoryTheory.Oplax.StrongTrans.toOplax η).Modification (CategoryTheory.Oplax.StrongTrans.toOplax θ)),
CategoryTheory.Oplax.StrongTrans.Modificatio... | null | true |
Std.Internal.List.getValueD_insertListConst_of_contains_eq_false | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((_ : α) × β)} {toInsert : List (α × β)}
{k : α} {fallback : β},
(List.map Prod.fst toInsert).contains k = false →
Std.Internal.List.getValueD k (Std.Internal.List.insertListConst l toInsert) fallback =
Std.Internal.List.getValueD k ... | null | true |
«term∃_,_» | Init.NotationExtra | Lean.ParserDescr | null | true |
TopCat.Presheaf.pullbackObjObjOfImageOpen | Mathlib.Topology.Sheaves.Presheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasColimits C] →
{X Y : TopCat} →
(f : X ⟶ Y) →
(ℱ : TopCat.Presheaf C Y) →
(U : TopologicalSpace.Opens ↑X) →
(H : IsOpen (⇑(CategoryTheory.ConcreteCategory.hom f) '' ↑U)) →... | If `f '' U` is open, then `f⁻¹ℱ U ≅ ℱ (f '' U)`. | true |
Antitone.add_const | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f : β → α} [AddRightMono α],
Antitone f → ∀ (a : α), Antitone fun x => f x + a | null | true |
CategoryTheory.Mon.instIsCommMonObj | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {M : CategoryTheory.Mon C} [inst_3 : CategoryTheory.IsCommMonObj M.X],
CategoryTheory.IsCommMonObj M | A commutative monoid object is a commutative monoid object in the category of monoid objects. | true |
Ideal.map_ofList | Mathlib.RingTheory.Regular.RegularSequence | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (rs : List R),
Ideal.map f (Ideal.ofList rs) = Ideal.ofList (List.map (⇑f) rs) | null | true |
Lean.Server.FileWorker.EditableDocumentCore.initSnap | Lean.Server.FileWorker.Utils | Lean.Server.FileWorker.EditableDocumentCore → Lean.Language.Lean.InitialSnapshot | Initial processing snapshot. | true |
CategoryTheory.IsCardinalFiltered.max._proof_1 | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ {κ : Cardinal.{u_1}} {K : Type u_2},
HasCardinalLT K κ → HasCardinalLT (CategoryTheory.Arrow (CategoryTheory.Discrete K)) κ | null | false |
_private.Init.Data.String.Iterator.0.String.Pos.Raw.get?.match_1.eq_1 | Init.Data.String.Iterator | ∀ (motive : String → String.Pos.Raw → Sort u_1) (s : String) (p : String.Pos.Raw)
(h_1 : (s : String) → (p : String.Pos.Raw) → motive s p),
(match s, p with
| s, p => h_1 s p) =
h_1 s p | null | true |
Flag.instMulActionOrderIso | Mathlib.Algebra.Order.Group.Action.Flag | {α : Type u_1} → [inst : Preorder α] → MulAction (α ≃o α) (Flag α) | null | true |
ContDiff.differentiable_deriv_two | Mathlib.Analysis.Calculus.ContDiff.Deriv | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F}, ContDiff 𝕜 2 f → Differentiable 𝕜 (deriv f) | null | true |
List.lookmap_id' | Mathlib.Data.List.Lookmap | ∀ {α : Type u_1} (f : α → Option α), (∀ (a b : α), b ∈ f a → a = b) → ∀ (l : List α), List.lookmap f l = l | null | true |
PosNum.testBit.eq_def | Mathlib.Data.Num.Lemmas | ∀ (x : PosNum) (x_1 : ℕ),
x.testBit x_1 =
match x, x_1 with
| PosNum.one, 0 => true
| PosNum.one, x => false
| a.bit0, 0 => false
| p.bit0, n.succ => p.testBit n
| a.bit1, 0 => true
| p.bit1, n.succ => p.testBit n | null | true |
WeierstrassCurve.HasGoodReduction.not_hasAdditiveReduction | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] {K : Type u_2}
[inst_3 : Field K] [inst_4 : Algebra R K] [inst_5 : IsFractionRing R K] {W : WeierstrassCurve K},
WeierstrassCurve.HasGoodReduction R W → ¬WeierstrassCurve.HasAdditiveReduction R W | null | true |
_private.Mathlib.Algebra.Divisibility.Prod.0.pi_dvd_iff._simp_1_1 | Mathlib.Algebra.Divisibility.Prod | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, (a ∣ b) = ∃ c, b = a * c | null | false |
CategoryTheory.Limits.BinaryBicone.inrCokernelCofork | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} → (c : CategoryTheory.Limits.BinaryBicone X Y) → CategoryTheory.Limits.CokernelCofork c.inr | A cokernel cofork for the cokernel of `BinaryBicone.inr`. It consists of the morphism
`BinaryBicone.fst`. | true |
Lean.Meta.Grind.EMatchTheoremConstraint.isValue.elim | Lean.Meta.Tactic.Grind.Extension | {motive : Lean.Meta.Grind.EMatchTheoremConstraint → Sort u} →
(t : Lean.Meta.Grind.EMatchTheoremConstraint) →
t.ctorIdx = 6 →
((bvarIdx : ℕ) → (strict : Bool) → motive (Lean.Meta.Grind.EMatchTheoremConstraint.isValue bvarIdx strict)) →
motive t | null | false |
Matroid.fundCircuit | Mathlib.Combinatorics.Matroid.Circuit | {α : Type u_1} → Matroid α → α → Set α → Set α | For an independent set `I` and some `e ∈ M.closure I \ I`,
`M.fundCircuit e I` is the unique circuit contained in `insert e I`.
For the fact that this is a circuit, see `Matroid.Indep.fundCircuit_isCircuit`,
and the fact that it is unique, see `Matroid.IsCircuit.eq_fundCircuit_of_subset`.
Has the junk value `{e}` if `e... | true |
_private.Mathlib.Tactic.FunProp.Core.0.Mathlib.Meta.FunProp.funProp._sparseCasesOn_1 | Mathlib.Tactic.FunProp.Core | {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)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → ... | null | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Functor.0.AlgebraicGeometry.ProjectiveSpectrum.comap._simp_3 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Functor | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (Z : Set (ProjectiveSpectrum 𝒜)), IsClosed Z = ∃ s, Z = ProjectiveSpectrum.zeroLocus 𝒜 s | null | false |
MvPolynomial.renameEquiv | Mathlib.Algebra.MvPolynomial.Rename | {σ : Type u_1} →
{τ : Type u_2} → (R : Type u_4) → [inst : CommSemiring R] → σ ≃ τ → MvPolynomial σ R ≃ₐ[R] MvPolynomial τ R | `MvPolynomial.rename e` is an equivalence when `e` is. | true |
DividedPowerAlgebra.lift'_apply | Mathlib.RingTheory.DividedPowerAlgebra.Init | ∀ {R : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {A : Type u_4}
[inst_3 : CommSemiring A] [inst_4 : Algebra R A] {f : ℕ × M → A} (hf_zero : ∀ (m : M), f (0, m) = 1)
(hf_smul : ∀ (n : ℕ) (r : R) (m : M), f (n, r • m) = r ^ n • f (n, m))
(hf_mul : ∀ (n p : ℕ) ... | null | true |
CategoryTheory.LocalizerMorphism.smallHomMap'._proof_3 | Mathlib.CategoryTheory.Localization.SmallHom | ∀ {C₁ : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} C₁] {W₁ : CategoryTheory.MorphismProperty C₁}
{C₂ : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} C₂] {W₂ : CategoryTheory.MorphismProperty C₂}
(Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {Y : C₁} {Y' : C₂}
[CategoryTheory.Localization.HasSmal... | null | false |
Set.iUnion_smul_eq_ofPred_exists | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {s : Set β}, ⋃ g, g • s = {a | ∃ g, g • a ∈ s} | null | true |
CategoryTheory.ShortComplex.HomologyData.recOn | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S : CategoryTheory.ShortComplex C} →
{motive : S.HomologyData → Sort u_1} →
(t : S.HomologyData) →
((left : S.LeftHomologyData) →
(right : S.RightHo... | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs.0.CategoryTheory.IsPullback.isoPullback_inv_snd._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) | null | false |
Std.DTreeMap.Internal.Impl.getEntry?.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α β) (k : α),
t.getEntry? k =
match t with
| Std.DTreeMap.Internal.Impl.leaf => none
| Std.DTreeMap.Internal.Impl.inner size k' v' l r =>
match compare k k' with
| Ordering.lt => l.getEntry? k
| Ordering.gt =>... | null | true |
AlgebraicGeometry.Scheme.affineOpens.eq_1 | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ (X : AlgebraicGeometry.Scheme), X.affineOpens = {U | AlgebraicGeometry.IsAffineOpen U} | null | true |
AddChar.zmod_char_primitive_of_eq_one_only_at_zero | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ {C : Type v} [inst : CommMonoid C] (n : ℕ) (ψ : AddChar (ZMod n) C), (∀ (a : ZMod n), ψ a = 1 → a = 0) → ψ.IsPrimitive | The converse: if the additive character takes the value `1` only at `0`,
then it is primitive. | true |
quasispectrum.preimage_algebraMap | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (S : Type u_3) {R : Type u_4} {A : Type u_5} [inst : Semifield R] [inst_1 : Field S] [inst_2 : NonUnitalRing A]
[inst_3 : Algebra R S] [inst_4 : Module S A] [IsScalarTower S A A] [SMulCommClass S A A] [inst_7 : Module R A]
[IsScalarTower R S A] {a : A}, ⇑(algebraMap R S) ⁻¹' quasispectrum S a = quasispectrum R a | null | true |
Std.DTreeMap.Equiv.getEntryLT_eq.match_1 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} {t₁ : Std.DTreeMap α β cmp} {k : α} (x : α)
(motive : x ∈ t₁ ∧ cmp x k = Ordering.lt → Prop) (x_1 : x ∈ t₁ ∧ cmp x k = Ordering.lt),
(∀ (h₁ : x ∈ t₁) (h₂ : cmp x k = Ordering.lt), motive ⋯) → motive x_1 | null | false |
Lean.JsonRpc.RequestID._sizeOf_1 | Lean.Data.JsonRpc | Lean.JsonRpc.RequestID → ℕ | null | false |
Mathlib.Tactic.Push.push | Mathlib.Tactic.Push | Mathlib.Tactic.Push.Config →
Option Lean.Meta.Simp.Discharge →
Mathlib.Tactic.Push.Head →
Lean.Elab.Tactic.Location →
optParam Mathlib.Tactic.BehaviorIfUnchanged Mathlib.Tactic.BehaviorIfUnchanged.error →
Lean.Elab.Tactic.TacticM Unit | Run the `push` tactic. | true |
_private.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.elabSetOption._regBuiltin.Lean.Elab.Term.elabSetOption.declRange_3 | Lean.Elab.BuiltinTerm | IO Unit | null | false |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.ediv_zero.match_1_1 | Init.Data.Int.DivMod.Bootstrap | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (a : ℕ), motive (Int.ofNat a)) → (∀ (a : ℕ), motive (Int.negSucc a)) → motive x | null | false |
ISize.ofIntLE.congr_simp | Init.Data.SInt.Lemmas | ∀ (i i_1 : ℤ) (e_i : i = i_1) (_hl : ISize.minValue.toInt ≤ i) (_hr : i ≤ ISize.maxValue.toInt),
ISize.ofIntLE i _hl _hr = ISize.ofIntLE i_1 ⋯ ⋯ | null | true |
Lean.Compiler.LCNF.NormFVarResult.erased.sizeOf_spec | Lean.Compiler.LCNF.CompilerM | sizeOf Lean.Compiler.LCNF.NormFVarResult.erased = 1 | null | true |
SimpleGraph.lapMatrix_mulVec_eq_zero_iff_forall_reachable | Mathlib.Combinatorics.SimpleGraph.LapMatrix | ∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V) [inst_1 : DecidableRel G.Adj] [inst_2 : DecidableEq V]
{x : V → ℝ}, (SimpleGraph.lapMatrix ℝ G).mulVec x = 0 ↔ ∀ (i j : V), G.Reachable i j → x i = x j | null | true |
CategoryTheory.Monad.ForgetCreatesColimits.liftedCocone | Mathlib.CategoryTheory.Monad.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{T : CategoryTheory.Monad C} →
{J : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} J] →
{D : CategoryTheory.Functor J T.Algebra} →
(c : CategoryTheory.Limits.Cocone (D.comp T.forget)) →
CategoryTheo... | (Impl) Construct the lifted cocone in `Algebra T` which will be colimiting. | true |
sdiff_inf_distrib | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (b c a : α), c \ (a ⊓ b) = c \ a ⊔ c \ b | null | true |
GenContFract.first_den_eq | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} {g : GenContFract K} [inst : DivisionRing K] {gp : GenContFract.Pair K},
g.s.get? 0 = some gp → g.dens 1 = gp.b | null | true |
orderBornology | Mathlib.Topology.Order.Bornology | {α : Type u_1} → [Lattice α] → [Nonempty α] → Bornology α | Order-bornology on a nonempty lattice. The bounded sets are the sets that are bounded both above
and below. | true |
Metric.vadd_eball | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : AddGroup G] [inst_2 : AddAction G X]
[IsIsometricVAdd G X] (c : G) (x : X) (r : ENNReal), c +ᵥ Metric.eball x r = Metric.eball (c +ᵥ x) r | null | true |
SimpleGraph.Walk.IsHamiltonianCycle.mk._flat_ctor | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a},
p.edges.Nodup → p ≠ SimpleGraph.Walk.nil → p.support.tail.Nodup → p.tail.IsHamiltonian → p.IsHamiltonianCycle | null | false |
_private.Init.Data.Array.Erase.0.Array.exists_erase_eq.match_1_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} [inst : BEq α] {a : α} {xs : Array α}
(motive :
(∃ a_1 ys zs,
(∀ b ∈ ys, ¬(a == b) = true) ∧ (a == a_1) = true ∧ xs = ys.push a_1 ++ zs ∧ xs.eraseP (BEq.beq a) = ys ++ zs) →
Prop)
(x :
∃ a_1 ys zs,
(∀ b ∈ ys, ¬(a == b) = true) ∧ (a == a_1) = true ∧ xs = ys.push a_1 ++ zs... | null | false |
_private.Mathlib.CategoryTheory.Presentable.OrthogonalReflection.0.CategoryTheory.OrthogonalReflection.isIso_toSucc_iff._simp_1_1 | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {Z : C}
[inst_1 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_2 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] {X Y : C} (f : X ⟶ Y)
(hf : W... | null | false |
_private.Mathlib.NumberTheory.LSeries.RiemannZeta.0.two_mul_riemannZeta_eq_tsum_int_inv_pow_of_even._proof_1_1 | Mathlib.NumberTheory.LSeries.RiemannZeta | ∀ {k : ℕ}, 2 ≤ k → ¬k = 0 | null | false |
Lean.Meta.Grind.EMatch.SearchState._sizeOf_1 | Lean.Meta.Tactic.Grind.EMatch | Lean.Meta.Grind.EMatch.SearchState → ℕ | null | false |
IterateMulAct.instMeasurableSpace | Mathlib.MeasureTheory.MeasurableSpace.Instances | {α : Type u_1} → {f : α → α} → MeasurableSpace (IterateMulAct f) | null | true |
_private.Mathlib.Data.Nat.Totient.0.Nat.totient_eq_one_iff.match_1_1 | Mathlib.Data.Nat.Totient | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (_ : Unit), motive 0) →
(∀ (_ : Unit), motive 1) → (∀ (_ : Unit), motive 2) → (∀ (n : ℕ), motive n.succ.succ.succ) → motive x | null | false |
ModuleCat.FilteredColimits.colimitModule | Mathlib.Algebra.Category.ModuleCat.FilteredColimits | {R : Type u} →
[inst : Ring R] →
{J : Type v} →
[inst_1 : CategoryTheory.SmallCategory J] →
[inst_2 : CategoryTheory.IsFiltered J] →
(F : CategoryTheory.Functor J (ModuleCat R)) → Module R ↑(ModuleCat.FilteredColimits.M F) | null | true |
CategoryTheory.Functor.RightExtension.precomp_obj_left | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {C' : Type u_2} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C'] [inst_2 : CategoryTheory.Category.{v_3, u_3} H]
[inst_3 : CategoryTheory.Category.{v_5, u_5} D] (L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C... | null | true |
Std.Http.URI.IsValidScheme | Std.Http.Data.URI.Basic | String → Prop | Proposition that `s` is a valid URI scheme per RFC 3986:
`scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )`.
The scheme value stored in this module is normalized to lowercase.
Reference: https://www.rfc-editor.org/rfc/rfc3986.html#section-3.1
| true |
AddMonCat.HasLimits.limitConeIsLimit._proof_9 | 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]
(s : CategoryTheory.Limits.Cone F),
(CategoryTheory.forget AddMonCat).map
(AddMonCat.ofHom
{
toFu... | null | false |
AddSubmonoid.centralizer._proof_1 | Mathlib.GroupTheory.Submonoid.Centralizer | ∀ {M : Type u_1} (S : Set M) [inst : AddMonoid M] {a b : M},
a ∈ S.addCentralizer → b ∈ S.addCentralizer → a + b ∈ S.addCentralizer | null | false |
CategoryTheory.Discrete.sumEquiv | Mathlib.CategoryTheory.Discrete.SumsProducts | {J : Type u_1} →
{K : Type u_2} → CategoryTheory.Discrete (J ⊕ K) ≌ CategoryTheory.Discrete J ⊕ CategoryTheory.Discrete K | The discrete category on a sum is equivalent to the sum of the
discrete categories. | true |
volume_set_coe_def | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} [inst : MeasureTheory.MeasureSpace α] (s : Set α),
MeasureTheory.volume = MeasureTheory.Measure.comap Subtype.val MeasureTheory.volume | null | true |
_private.Std.Sync.Barrier.0.Std.BarrierState.generationId | Std.Sync.Barrier | Std.BarrierState✝ → ℕ | null | true |
Lean.Omega.IntList.smul_nil | Init.Omega.IntList | ∀ {i : ℤ}, i * [] = [] | null | true |
LieAlgebra.HasCentralRadical.mk | Mathlib.Algebra.Lie.Semisimple.Defs | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieAlgebra.radical R L = LieAlgebra.center R L → LieAlgebra.HasCentralRadical R L | null | true |
Ordnode.insert._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α | null | false |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.H1ToTensorOfIsTrivial_H1π_single._simp_1_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {p : Submodule R M}
(x : M), Submodule.Quotient.mk x = ↑x | null | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.unusedVariablesIgnoreFnsExt.match_3 | Lean.Linter.UnusedVariables | (motive : List Lean.Name × Array Lean.Linter.IgnoreFunction → Sort u_1) →
(x : List Lean.Name × Array Lean.Linter.IgnoreFunction) →
((entries : List Lean.Name) → (s : Array Lean.Linter.IgnoreFunction) → motive (entries, s)) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.