name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CochainComplex.HomComplex.Cochain.toSingleMk_v_eq_zero | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X : C} {K : CochainComplex C ℤ} {p q : ℤ} (f : K.X p ⟶ X) {n : ℤ}
(h : p + n = q) (p' q' : ℤ) (hpq' : p' + n = q'),
p' ≠ p → (CochainComplex.HomComplex.Cochain.toSingl... | null | true |
LieAlgebra.IsKilling.corootSubmodule._proof_2 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_2} {L : Type u_1} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L] {H : LieSubalgebra K L},
AddSubmonoidClass (LieSubmodule K (↥H) L) L | null | false |
ByteArray.size_set | Batteries.Data.ByteArray | ∀ (a : ByteArray) (i : Fin a.size) (v : UInt8), (a.set (↑i) v ⋯).size = a.size | null | true |
Homeomorph.instEquivLike._proof_2 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
Function.RightInverse h.invFun h.toFun | null | false |
List.extract_eq_drop_take | Init.Data.List.Basic | ∀ {α : Type u_1} {l : List α} {start stop : ℕ}, l.extract start stop = List.take (stop - start) (List.drop start l) | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Basic.0.Std.Tactic.BVDecide.BVExpr.toString.match_1.eq_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (motive : (w : ℕ) → Std.Tactic.BVDecide.BVExpr w → Sort u_1) (w idx : ℕ)
(h_1 : (w idx : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var idx))
(h_2 : (w : ℕ) → (val : BitVec w) → motive w (Std.Tactic.BVDecide.BVExpr.const val))
(h_3 :
(len w start : ℕ) →
(expr : Std.Tactic.BVDecide.BVExpr w) → motive le... | null | true |
CompHaus.toStonean | Mathlib.Topology.Category.Stonean.Basic | (X : CompHaus) → [CategoryTheory.Projective X] → Stonean | `Projective` implies `Stonean`. | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution'.mk.sizeOf_spec | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} [inst_1 : SizeOf K]
(a b c : NumberField.RingOfIntegers K) (u : (NumberField.RingOfIntegers K)ˣ) (ha : ¬hζ.toInteger - 1 ∣ a)
(hb : ¬hζ.toInteger - 1 ∣ b) (hc : c ≠ 0) (coprime : IsCoprime a b) (hcdvd : hζ.toInteger - 1 ∣ c)
(H : a ^ 3 + b ^ 3 =... | null | true |
FirstOrder.Language.Embedding.substructureEquivMap.match_3 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_4} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.Embedding M N) (s : L.Substructure M) (motive : ↥(FirstOrder.Language.Substructure.map f.toHom s) → Prop)
(x : ↥(FirstOrder.Language.Substructure.map f.toHom s)),
(∀ (val : N) (hn : val ∈ FirstOrder.La... | null | false |
Std.ExtHashMap.getKey_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → ∀ {h : k' ∈ m.insertManyIfNewUnit l}, (m.insertManyIfNewUnit l).getK... | null | true |
Polynomial.Separable.of_mul_right | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommSemiring R] {f g : Polynomial R}, (f * g).Separable → g.Separable | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.oppositeLeftAction_actionHom_op | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {c c' : C} {d d' : D} (f : c ⟶ c') (g : d ⟶ d'),
CategoryTheory.MonoidalCateg... | null | true |
add_neg' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddLeftMono α] {a b : α}, a < 0 → b < 0 → a + b < 0 | **Alias** of `Left.add_neg'`. | true |
Complex.arg_cos_add_sin_mul_I | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {θ : ℝ}, θ ∈ Set.Ioc (-Real.pi) Real.pi → (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I).arg = θ | null | true |
biUnion_associatedPrimes_eq_zero_divisors | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[IsNoetherianRing R], ⋃ p ∈ associatedPrimes R M, ↑p = {r | ∃ x, x ≠ 0 ∧ r • x = 0} | null | true |
Bundle.Pretrivialization.restrictPreimage'._proof_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_2} {Z : Type u_1} {proj : Z → B} (s : Set B) (z : ↑(proj ⁻¹' s)), ↑z ∈ proj ⁻¹' s | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterMapM.match_1.splitter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | {β β' : Type u_1} →
{n : Type u_1 → Type u_2} →
{f : β → n (Option β')} →
[inst : MonadAttach n] →
(out : β) →
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) →
(__do_lift : Subtype (MonadAttach.CanReturn (f out))) →
((hf : MonadAttach.CanReturn (f o... | null | true |
CategoryTheory.MorphismProperty.LeftFraction.ofHom.eq_1 | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C) {X Y : C}
(f : X ⟶ Y) [inst_1 : W.ContainsIdentities],
CategoryTheory.MorphismProperty.LeftFraction.ofHom W f =
{ Y' := Y, f := f, s := CategoryTheory.CategoryStruct.id Y, hs := ⋯ } | null | true |
Set.countable_union | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s t : Set α}, (s ∪ t).Countable ↔ s.Countable ∧ t.Countable | null | true |
Int.Linear.cooper_right_split_dvd_cert | Init.Data.Int.Linear | Int.Linear.Poly → Int.Linear.Poly → ℤ → ℤ → Bool | null | true |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.laxBraidedToCommMon._proof_2 | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C]
{X Y Z : CategoryTheory.LaxBraidedFunctor (CategoryTheory.Discrete PUnit.{u_1 + 1}) C} (f : X ⟶ Y) (g : Y ⟶ Z),
((CategoryTheory.Functor.mapCommMonFunctor (Catego... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.mem_of_mem_insertIfNew._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
SemidirectProduct.card | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N},
Nat.card (N ⋊[φ] G) = Nat.card N * Nat.card G | null | true |
_private.Mathlib.Analysis.Normed.Module.RCLike.Real.0.closure_ball._simp_1_1 | Mathlib.Analysis.Normed.Module.RCLike.Real | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True | null | false |
Std.TreeMap.Raw.getKeyD_insertManyIfNewUnit_list_of_mem | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α Unit cmp} [Std.TransCmp cmp],
t.WF → ∀ {l : List α} {k fallback : α}, k ∈ t → (t.insertManyIfNewUnit l).getKeyD k fallback = t.getKeyD k fallback | null | true |
Invertible.algebraMapOfInvertibleAlgebraMap._proof_2 | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₗ[R] B),
f 1 = 1 → ∀ {r : R} (h : Invertible ((algebraMap R A) r)), (algebraMap R B) r * f ⅟((algebraMap R A) r) = 1 | null | false |
Orientation.rotation_neg_orientation_eq_neg | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (θ : Real.Angle), (-o).rotation θ = o.rotation (-θ) | Negating the orientation negates the angle in `rotation`. | true |
NNReal.coe_add._simp_1 | Mathlib.Data.NNReal.Defs | ∀ (r₁ r₂ : NNReal), ↑r₁ + ↑r₂ = ↑(r₁ + r₂) | null | false |
_private.Batteries.Data.Array.Scan.0.Array.scanrM.loop_toList._proof_1_2 | Batteries.Data.Array.Scan | ∀ {α : Type u_1} {as : Array α} {stop start : ℕ}, start - stop = 0 → stop < start → False | null | false |
WithAbs.instSemiring._proof_8 | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) (a b : WithAbs v), a + b = b + a | null | false |
HomotopyCategory.spectralObjectMappingCone._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.SpectralObject | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C]
(D₁ D₂ : CategoryTheory.ComposableArrows (CochainComplex C ℤ) 2) (φ : D₁ ⟶ D₂),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.ComposableArrows.... | null | false |
MeasureTheory.VectorMeasure.instAddCommGroup._proof_3 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : TopologicalSpace M] [IsTopologicalAddGroup M],
ContinuousConstSMul ℤ M | null | false |
AlgebraicGeometry.Scheme.GlueData.instPreservesColimitWalkingMultispanProdJMultispanDiagramForget | Mathlib.AlgebraicGeometry.Gluing | ∀ (D : AlgebraicGeometry.Scheme.GlueData),
CategoryTheory.Limits.PreservesColimit D.diagram.multispan AlgebraicGeometry.Scheme.forget | null | true |
_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.abstractAtoms.match_1.splitter | Lean.Meta.Tactic.AC.Main | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) → (Unit → motive none) → ((inst : Lean.Expr) → motive (some inst)) → motive __do_lift | null | true |
TopCat.Presheaf.germ | Mathlib.Topology.Sheaves.Stalks | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasColimits C] →
{X : TopCat} →
(F : TopCat.Presheaf C X) →
(U : TopologicalSpace.Opens ↑X) → (x : ↑X) → x ∈ U → (F.obj (Opposite.op U) ⟶ F.stalk x) | The germ of a section of a presheaf over an open at a point of that open.
| true |
Valuation.RankOne.ofRankLeOneStruct._proof_3 | Mathlib.RingTheory.Valuation.RankOne | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : ValuativeRel R] [ValuativeRel.IsNontrivial R],
(ValuativeRel.valuation R).IsNontrivial | null | false |
_private.Mathlib.Algebra.Order.ToIntervalMod.0.QuotientAddGroup.circularPreorder._simp_6 | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} [hp' : Fact (0 < p)] {x₁ x₂ x₃ : α}, btw ↑x₁ ↑x₂ ↑x₃ = (toIcoMod ⋯ x₁ x₂ ≤ toIocMod ⋯ x₁ x₃) | null | false |
Lean.MonadNameGenerator.setNGen | Init.Meta.Defs | {m : Type → Type} → [self : Lean.MonadNameGenerator m] → Lean.NameGenerator → m Unit | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.partialMatch_add_one_add_one_iff._proof_1_9 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat : ByteArray} {s : ByteArray} {stackPos : ℕ} {needlePos : ℕ}, stackPos + 1 ≤ s.size → ¬stackPos < s.size → False | null | false |
Std.Sat.AIG.Entrypoint.ref | Std.Sat.AIG.Basic | {α : Type} → [inst : DecidableEq α] → [inst_1 : Hashable α] → (self : Std.Sat.AIG.Entrypoint α) → self.aig.Ref | The reference to the node in `aig` that this `Entrypoint` targets.
| true |
Aesop.PhaseSpec.ctorIdx | Aesop.Builder.Basic | Aesop.PhaseSpec → ℕ | null | false |
Int.sub_le_sub_left_iff | Init.Data.Int.Order | ∀ {a b c : ℤ}, c - a ≤ c - b ↔ b ≤ a | null | true |
CompositionAsSet.toComposition_length | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (c : CompositionAsSet n), c.toComposition.length = c.length | null | true |
_private.Mathlib.RingTheory.DedekindDomain.Factorization.0.IsDedekindDomain.exists_add_spanSingleton_mul_eq._simp_1_7 | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [Nontrivial M₀] (x : ↥(nonZeroDivisors M₀)), (↑x = 0) = False | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.existsRatHint_of_ratHintsExhaustive._proof_1_27 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) (ratHints : Array (ℕ × Array ℕ)),
∀ i < f.clauses.toList.length,
i < f.clauses.size →
∀ (j : Fin (Array.map (fun x => x.1) ratHints).toList.length),
(Array.map (fun x => x.1) ratHints).toList.get j = i →
∀ (j_in_bounds : ↑j... | null | false |
CategoryTheory.MonoidalCategory.DayConvolution.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{F G : CategoryTheory.Functor C V} →
(convol... | null | false |
IsCoinitial | Mathlib.Order.Bounds.Defs | {α : Type u_1} → [LE α] → Set α → Prop | A set is coinitial when for every `x : α` there exists `y ∈ s` with `y ≤ x`. | true |
Std.DHashMap.Internal.Raw₀.Const.insertListₘ._sunfold | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : Type v} →
[BEq α] →
[Hashable α] → (Std.DHashMap.Internal.Raw₀ α fun x => β) → List (α × β) → Std.DHashMap.Internal.Raw₀ α fun x => β | null | false |
Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality.mkNaturalityRightUnitor | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {m : Type → Type} →
[self : Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality m] →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Lean.Expr | The naturality for the right unitor. | true |
Lean.Lsp.DependencyBuildMode.recOn | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.DependencyBuildMode → Sort u} →
(t : Lean.Lsp.DependencyBuildMode) →
motive Lean.Lsp.DependencyBuildMode.always →
motive Lean.Lsp.DependencyBuildMode.once → motive Lean.Lsp.DependencyBuildMode.never → motive t | null | false |
_private.Mathlib.NumberTheory.LucasLehmer.0.Mathlib.Meta.Positivity.evalMersenne._sparseCasesOn_4 | Mathlib.NumberTheory.LucasLehmer | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{pα : Q(PartialOrder «$α»)} →
{e : Q(«$α»)} →
{motive : Mathlib.Meta.Positivity.Strictness zα pα e → Sort u} →
(t : Mathlib.Meta.Positivity.Strictness zα pα e) →
((pf : Q(0 < «$e»)) → motive (Mathlib.Meta.... | null | false |
TopCat.GlueData.MkCore.mk.sizeOf_spec | Mathlib.Topology.Gluing | ∀ {J : Type u} (U : J → TopCat) (V : (i : J) → J → TopologicalSpace.Opens ↑(U i))
(t :
(i j : J) →
(TopologicalSpace.Opens.toTopCat (U i)).obj (V i j) ⟶ (TopologicalSpace.Opens.toTopCat (U j)).obj (V j i))
(V_id : ∀ (i : J), V i i = ⊤) (t_id : ∀ (i : J), ⇑(CategoryTheory.ConcreteCategory.hom (t i i)) = id... | null | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.toPreOneHypercover_Y | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {X : C} (data : F.PreOneHypercoverDenseData X) (x x_1 : data.I₀)
(j : data.I₁ x x_1), data.toPreOneHypercover.Y j = F.obj (data.Y j) | null | true |
GroupCone.mem_oneLE._simp_2 | Mathlib.Algebra.Order.Group.Cone | ∀ {H : Type u_1} [inst : CommGroup H] [inst_1 : PartialOrder H] [inst_2 : IsOrderedMonoid H] {a : H},
(a ∈ GroupCone.oneLE H) = (1 ≤ a) | null | false |
PFun.restrict | Mathlib.Data.PFun | {α : Type u_1} → {β : Type u_2} → (f : α →. β) → {p : Set α} → p ⊆ f.Dom → α →. β | Restrict a partial function to a smaller domain. | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution'.hcdvd | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3}
(self : FermatLastTheoremForThreeGen.Solution'✝ hζ), hζ.toInteger - 1 ∣ FermatLastTheoremForThreeGen.Solution'.c✝ self | null | true |
symmDiff_eq_bot._simp_1 | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, (symmDiff a b = ⊥) = (a = b) | null | false |
Std.DTreeMap.Internal.Impl.balanceL.match_3.congr_eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ) (lk : α)
(lv : β lk)
(motive :
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTre... | null | true |
Std.Sat.AIG.ExtendTarget.w | Std.Sat.AIG.Basic | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] → {aig : Std.Sat.AIG α} → {newWidth : ℕ} → aig.ExtendTarget newWidth → ℕ | null | true |
Lean.Syntax.getOptional? | Init.Prelude | Lean.Syntax → Option Lean.Syntax | Assuming `stx` was parsed by `optional`, returns the enclosed syntax
if it parsed something and `none` otherwise.
| true |
DivisibleHull.nsmul_mk | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_1} [inst : AddCommMonoid M] (a : ℕ) (m : M) (s : ℕ+),
a • DivisibleHull.mk m s = DivisibleHull.mk (a • m) s | null | true |
Std.Time.DateFormatSymbols.mk | Std.Time.Format.DateFormat | Vector String 12 →
Vector String 12 →
Vector String 12 →
Vector String 7 →
Vector String 7 →
Vector String 7 →
Vector String 2 →
Vector String 2 →
Vector String 2 →
Vector String 4 →
Vector String 4 →
... | null | true |
CategoryTheory.PreservesFiniteLimitsOfFlat.uniq | Mathlib.CategoryTheory.Functor.Flat | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type v₁} [inst_2 : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J]
(F : CategoryTheory.Functor C D) [CategoryTheory.RepresentablyFlat F] {K : CategoryTheory.Functor J C}
{c :... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_eq_get!_getKey?._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
CategoryTheory.Limits.Cocone.whisker_ι | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
(E : CategoryTheory.Functor K J) (c : CategoryTheory.Limits.Cocone F),
(CategoryTheory.Limits.Cocone.... | null | true |
Lean.Syntax.decodeStrLitAux._unsafe_rec | Init.Meta.Defs | String → String.Pos.Raw → String → Option String | null | false |
ProbabilityTheory.IsRatCondKernelCDFAux.isRatCondKernelCDF | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{κ : ProbabilityTheory.Kernel α (β × ℝ)} {ν : ProbabilityTheory.Kernel α β} {f : α × β → ℚ → ℝ},
ProbabilityTheory.IsRatCondKernelCDFAux f κ ν →
∀ [ProbabilityTheory.IsFiniteKernel κ] [ProbabilityTheory.IsFiniteKernel ν],
Pr... | null | true |
LocallyConstant.piecewise._proof_3 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {C₁ C₂ : Set X}, ∀ x ∈ C₁ ∩ C₂, x ∈ C₂ | null | false |
_private.Aesop.BuiltinRules.0.Aesop.BuiltinRules.pEmpty_false.match_1_1 | Aesop.BuiltinRules | ∀ (motive : PEmpty.{u_1} → Prop) (h : PEmpty.{u_1}), motive h | null | false |
instCompleteLinearOrderENat._proof_6 | Mathlib.Data.ENat.Lattice | ∀ (s : Set ℕ∞), IsGLB s (sInf s) | null | false |
Std.Time.Millisecond.instLawfulEqOrdOffset | Std.Time.Time.Unit.Millisecond | Std.LawfulEqOrd Std.Time.Millisecond.Offset | null | true |
Array.find? | Init.Data.Array.Basic | {α : Type u} → (α → Bool) → Array α → Option α | Returns the first element of the array for which the predicate `p` returns `true`, or `none` if no
such element is found.
Examples:
* `#[7, 6, 5, 8, 1, 2, 6].find? (· < 5) = some 1`
* `#[7, 6, 5, 8, 1, 2, 6].find? (· < 1) = none`
| true |
Lean.LocalDecl.replaceFVarId | Lean.LocalContext | Lean.FVarId → Lean.Expr → Lean.LocalDecl → Lean.LocalDecl | null | true |
Nat.Partrec.below.casesOn | Mathlib.Computability.Partrec | ∀ {motive : (a : ℕ →. ℕ) → Nat.Partrec a → Prop}
{motive_1 : {a : ℕ →. ℕ} → (t : Nat.Partrec a) → Nat.Partrec.below t → Prop} {a : ℕ →. ℕ} {t : Nat.Partrec a}
(t_1 : Nat.Partrec.below t),
motive_1 Nat.Partrec.zero ⋯ →
motive_1 Nat.Partrec.succ ⋯ →
motive_1 Nat.Partrec.left ⋯ →
motive_1 Nat.Partr... | null | false |
Multiset.prod_min_le | Mathlib.Algebra.Order.BigOperators.Group.Multiset | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] [inst_1 : LinearOrder α] [IsOrderedMonoid α] {s : Multiset ι}
{f g : ι → α}, (Multiset.map (fun i => min (f i) (g i)) s).prod ≤ min (Multiset.map f s).prod (Multiset.map g s).prod | null | true |
MeasureTheory.JordanDecomposition.instSMul._proof_4 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (r : NNReal) (j : MeasureTheory.JordanDecomposition α),
(↑r • j.posPart).MutuallySingular (r • j.negPart) | null | false |
RBTree.RBSet.mergeWith | BatteriesRecycling.RBTree.Basic | {α : Type u_1} → {cmp : α → α → Ordering} → (α → α → α) → RBTree.RBSet α cmp → RBTree.RBSet α cmp → RBTree.RBSet α cmp | `O(n₂ * log (n₁ + n₂))`. Merges the maps `t₁` and `t₂`. If equal keys exist in both,
then use `mergeFn a₁ a₂` to produce the new merged value.
| true |
SaturatedAddSubmonoid._sizeOf_1 | Mathlib.Algebra.Group.Submonoid.Saturation | {M : Type u_1} → {inst : AddZeroClass M} → [SizeOf M] → SaturatedAddSubmonoid M → ℕ | null | false |
spectrum_realPart' | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.RealImaginaryPart | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : Algebra ℂ A]
[inst_4 : StarModule ℂ A] [ContinuousFunctionalCalculus ℂ A IsStarNormal] (a : A),
autoParam (IsStarNormal a) spectrum_realPart'._auto_1 → spectrum ℝ ↑(realPart a) = Complex.re '' spectrum ℂ a | null | true |
FirstOrder.Language.Term.restrictVar | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} → {β : Type v'} → [inst : DecidableEq α] → (t : L.Term α) → (↥t.varFinset → β) → L.Term β | Restricts a term to use only a set of the given variables. | true |
ENNReal.nnreal_smul_lt_top_iff | Mathlib.Data.ENNReal.Action | ∀ {x : NNReal} {y : ENNReal}, x ≠ 0 → (x • y < ⊤ ↔ y < ⊤) | null | true |
SmoothBumpCovering.mk.inj | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {ι : Type uι} {E : Type uE} {inst : NormedAddCommGroup E} {inst_1 : NormedSpace ℝ E} {H : Type uH}
{inst_2 : TopologicalSpace H} {I : ModelWithCorners ℝ E H} {M : Type uM} {inst_3 : TopologicalSpace M}
{inst_4 : ChartedSpace H M} {inst_5 : FiniteDimensional ℝ E} {s : Set M} {c : ι → M}
{toFun : (i : ι) → Smooth... | null | true |
CategoryTheory.ObjectProperty.fullSubcategoryCongr_functor | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P P' : CategoryTheory.ObjectProperty C} (h : P = P'),
(CategoryTheory.ObjectProperty.fullSubcategoryCongr h).functor = CategoryTheory.ObjectProperty.ιOfLE ⋯ | null | true |
Filter.comap_embedding_atBot | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : Preorder γ] {e : β → γ},
(∀ (b₁ b₂ : β), e b₂ ≤ e b₁ ↔ b₂ ≤ b₁) → (∀ (c : γ), ∃ b, e b ≤ c) → Filter.comap e Filter.atBot = Filter.atBot | null | true |
LieSubmodule.instAddCommMonoid._proof_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : LieSubmodule R L M), nsmulRec 0 x = 0 | null | false |
LocalizedModule.liftOn._proof_2 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_1} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] {α : Type u_3} (f : M × ↥S → α),
(∀ (p p' : M × ↥S), p ≈ p' → f p = f p') → ∀ (a b : M × ↥S), a ≈ b → f a = f b | null | false |
NeZero | Init.Data.NeZero | {R : Type u_1} → [Zero R] → R → Prop | A type-class version of `n ≠ 0`. | true |
SemiNormedGrp.Hom.mk.injEq | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M N : SemiNormedGrp} (hom' hom'_1 : NormedAddGroupHom M.carrier N.carrier),
({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | null | true |
Vector.snd_lt_add_of_mem_zipIdx | Init.Data.Vector.Range | ∀ {α : Type u_1} {n : ℕ} {x : α × ℕ} {k : ℕ} {xs : Vector α n}, x ∈ xs.zipIdx k → x.2 < k + n | null | true |
CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_p₂ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
(S : J.Cover X) (x x_1 : S.Arrow) (r : x.Relation x_1), S.preOneHypercover.p₂ r = r.g₂ | null | true |
ArchimedeanClass.exists_int_ge_of_mk_nonneg | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] {x : R},
0 ≤ ArchimedeanClass.mk x → ∃ n, x ≤ ↑n | null | true |
CliffordAlgebra.EvenHom.mk | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{Q : QuadraticForm R M} →
{A : Type u_3} →
[inst_3 : Ring A] →
[inst_4 : Algebra R A] →
(bilin : M →ₗ[R] M →ₗ[R] A) →
... | null | true |
Std.ExtHashMap.getD_diff_of_mem_right | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β}, k ∈ m₂ → (m₁ \ m₂).getD k fallback = fallback | null | true |
OrderAddMonoidHom.coe_comp_orderHom | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : AddZeroClass α] [inst_4 : AddZeroClass β] [inst_5 : AddZeroClass γ] (f : β →+o γ) (g : α →+o β),
↑(f.comp g) = (↑f).comp ↑g | null | true |
CategoryTheory.CostructuredArrow.homMk'_id._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {T : D} {S : CategoryTheory.Functor C D}
(f : CategoryTheory.CostructuredArrow S T),
CategoryTheory.CostructuredArrow.mk
(CategoryTheory.CategoryStruct.comp (S.map (CategoryTheory.Ca... | null | false |
Std.DTreeMap.Internal.Cell.get?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.OrientedOrd α] [inst_2 : Std.LawfulEqOrd α] {k : α}
(c : Std.DTreeMap.Internal.Cell α β (compare k)),
c.get? =
match h : c.inner with
| none => none
| some p => some (cast ⋯ p.snd) | null | true |
DFinsupp.instCanonicallyOrderedAddOfAddLeftMono | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} (α : ι → Type u_2) [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : (i : ι) → Sub (α i)] [∀ (i : ι), OrderedSub (α i)]
[∀ (i : ι), AddLeftMono (α i)], CanonicallyOrderedAdd (Π₀ (i : ι), α i) | null | true |
Set.pairwise_iUnion₂_iff | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set (Set α)},
DirectedOn (fun x1 x2 => x1 ⊆ x2) s → ((⋃ a ∈ s, a).Pairwise r ↔ ∀ a ∈ s, a.Pairwise r) | null | true |
ClosureOperator.noConfusion | Mathlib.Order.Closure | {P : Sort u} →
{α : Type u_1} →
{inst : Preorder α} →
{t : ClosureOperator α} →
{α' : Type u_1} →
{inst' : Preorder α'} →
{t' : ClosureOperator α'} → α = α' → inst ≍ inst' → t ≍ t' → ClosureOperator.noConfusionType P t t' | null | false |
_private.Init.Data.List.Find.0.List.lt_findIdx_iff._proof_1_3 | Init.Data.List.Find | ∀ {α : Type u_1} (xs : List α) (p : α → Bool),
∀ i < List.findIdx p xs, List.findIdx p xs ≤ xs.length → ¬i < xs.length → False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.