name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.MorphismProperty.Q' | Mathlib.CategoryTheory.Localization.HasLocalization | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(W : CategoryTheory.MorphismProperty C) → [inst_1 : W.HasLocalization] → CategoryTheory.Functor C W.Localization' | The localization functor `C ⥤ W.Localization'`
that is fixed by the `[HasLocalization W]` instance. | true |
CategoryTheory.ShortComplex.LeftHomologyData.cyclesIso_inv_comp_iCycles | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) [inst_2 : S.HasLeftHomology],
CategoryTheory.CategoryStruct.comp h.cyclesIso.inv S.iCycles = h.i | null | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremNew.kind | Lean.Elab.Tactic.Do.Internal.VCGen.SpecDB | Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremNew → Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremKind | The kind of spec theorem: triple or simp. | true |
Fin.cast_eq_cast | Mathlib.Data.Fin.SuccPred | ∀ {n m : ℕ} (h : n = m), Fin.cast h = cast ⋯ | While in many cases `Fin.cast` is better than `Equiv.cast`/`cast`, sometimes we want to apply
a generic theorem about `cast`. | true |
Submodule.lTensorOne'._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Submodule | ∀ {R : Type u_2} {S : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S]
(N : Submodule R S), ((Subalgebra.toSubmodule ⊥).mulMap N).range = N | null | false |
CategoryTheory.CostructuredArrow.toOver_obj_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor D T) (X : T)
(X_1 : CategoryTheory.Comma (F.comp (CategoryTheory.Functor.id T)) (CategoryTheory.Functor.fromPUnit X)),
((CategoryTheory.CostructuredArrow.toOver F X).... | null | true |
Computation.get.congr_simp | Mathlib.Data.WSeq.Productive | ∀ {α : Type u} (s s_1 : Computation α) (e_s : s = s_1) [h : s.Terminates], s.get = s_1.get | null | true |
Real.tsum_eq_tsum_fourier_of_rpow_decay_of_summable | Mathlib.Analysis.Fourier.PoissonSummation | ∀ {f : ℝ → ℂ},
Continuous f →
∀ {b : ℝ},
1 < b →
(f =O[Filter.cocompact ℝ] fun x => |x| ^ (-b)) →
(Summable fun n => FourierTransform.fourier f ↑n) →
∀ (x : ℝ), ∑' (n : ℤ), f (x + ↑n) = ∑' (n : ℤ), FourierTransform.fourier f ↑n * (fourier n) ↑x | **Poisson's summation formula**, assuming that `f` decays as
`|x| ^ (-b)` for some `1 < b` and its Fourier transform is summable. | true |
Int8.toUInt8_neg | Init.Data.SInt.Lemmas | ∀ (a : Int8), (-a).toUInt8 = -a.toUInt8 | null | true |
uniformContinuous_of_const | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {c : α → β},
(∀ (a b : α), c a = c b) → UniformContinuous c | null | true |
Lean.Lsp.TextDocumentIdentifier.uri | Lean.Data.Lsp.Basic | Lean.Lsp.TextDocumentIdentifier → Lean.Lsp.DocumentUri | null | true |
CategoryTheory.Functor.initial_iff_comp_initial_full_faithful | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D E) [G.Initial] [G.Full] [G.Faithful], F.Initial ↔ (F.comp G).Initial | null | true |
CategoryTheory.Functor.mapCommGrpNatTrans_app_hom_hom_hom | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.CartesianMonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
... | null | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.andFlatteningPass.processFVar._sparseCasesOn_1 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Asymptotics.IsLittleO.eventually_mul_div_cancel | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {𝕜 : Type u_15} [inst : NormedDivisionRing 𝕜] {l : Filter α} {u v : α → 𝕜},
u =o[l] v → u / v * v =ᶠ[l] u | If `u = o(v)` along `l`, then `(u / v) * v = u` eventually at `l`. | true |
_private.Mathlib.Combinatorics.Enumerative.Catalan.Basic.0.gosperCatalan.eq_1 | Mathlib.Combinatorics.Enumerative.Catalan.Basic | ∀ (n j : ℕ), gosperCatalan✝ n j = ↑j.centralBinom * ↑(n - j).centralBinom * (2 * ↑j - ↑n) / (2 * ↑n * (↑n + 1)) | null | true |
CategoryTheory.Limits.Trident.IsLimit.homIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {t : CategoryTheory.Limits.Trident f} (ht : CategoryTheory.Limits.IsLimit t) (Z : C)
(x : Z ⟶ t.pt), ↑(CategoryTheory.Limits.Trident.IsLimit.lift' ht ↑⟨CategoryTheory.CategoryStruct.comp x... | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.coneBack._proof_9 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {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] {X : C} {K : CategoryTheory.Functor J (CategoryTheory.Over X)}
{X_1 Y Z : CategoryTheory.Limits.Cone (CategoryTheory.WithTerminal.liftFromOver.obj K)} (f : X_1 ⟶ Y) (g : Y ⟶ Z)
(j : J),
... | null | false |
Aesop.BuilderName.constructors.sizeOf_spec | Aesop.Rule.Name | sizeOf Aesop.BuilderName.constructors = 1 | null | true |
Nat.pow_lt_ascFactorial | Mathlib.Data.Nat.Factorial.Basic | ∀ (n : ℕ) {k : ℕ}, 2 ≤ k → (n + 1) ^ k < (n + 1).ascFactorial k | null | true |
WeierstrassCurve.Jacobian.isUnit_Y_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P : Fin 3 → F},
W.Nonsingular P → P 2 = 0 → IsUnit (P 1) | null | true |
Mathlib.Tactic.Order.Graph.findSCCsImp | Mathlib.Tactic.Order.Graph.Tarjan | Mathlib.Tactic.Order.Graph → StateM Mathlib.Tactic.Order.Graph.TarjanState Unit | Implementation of `findSCCs` in the `StateM TarjanState` monad. | true |
Nat.testBit_two_pow_sub_one | Init.Data.Nat.Bitwise.Lemmas | ∀ (n i : ℕ), (2 ^ n - 1).testBit i = decide (i < n) | null | true |
Std.DHashMap.Raw.Const.get?_congr | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {a b : α}, (a == b) = true → Std.DHashMap.Raw.Const.get? m a = Std.DHashMap.Raw.Const.get? m b | null | true |
CategoryTheory.MorphismProperty.regularMono.respectsIso | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C], (CategoryTheory.MorphismProperty.regularMono C).RespectsIso | null | true |
CategoryTheory.Limits.Sigma.map_comp_map | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g h : α → C}
[inst_1 : CategoryTheory.Limits.HasCoproduct f] [inst_2 : CategoryTheory.Limits.HasCoproduct g]
[inst_3 : CategoryTheory.Limits.HasCoproduct h] (q : (a : α) → f a ⟶ g a) (q' : (a : α) → g a ⟶ h a),
CategoryTheory.CategoryStruct... | null | true |
Set.fintypeLENat._simp_1 | Mathlib.Data.Set.Finite.Basic | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | null | false |
TopCat.«term∂𝔻_» | Mathlib.Topology.Category.TopCat.Sphere | Lean.ParserDescr | `∂𝔻 n` denotes the boundary of the `n`-disk. | true |
_private.Mathlib.Analysis.MellinInversion.0.mellin_eq_fourier._simp_1_1 | Mathlib.Analysis.MellinInversion | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDense.0.HasCompactSupport.exists_simpleFunc_approx_of_prod.match_1_1 | Mathlib.MeasureTheory.Function.SimpleFuncDense | ∀ {X : Type u_1} {Y : Type u_2} {α : Type u_3} [inst : MeasurableSpace X] [inst_1 : MeasurableSpace Y]
[inst_2 : PseudoMetricSpace α] {f : X × Y → α} {ε : ℝ} ⦃t' : Set (X × Y)⦄
(motive : (∃ g s, MeasurableSet s ∧ t' ⊆ s ∧ ∀ x ∈ s, dist (f x) (g x) < ε) → Prop)
(h : ∃ g s, MeasurableSet s ∧ t' ⊆ s ∧ ∀ x ∈ s, dist ... | null | false |
Nat.lcm.eq_1 | Mathlib.Algebra.Order.Antidiag.Nat | ∀ (m n : ℕ), m.lcm n = m * n / m.gcd n | null | true |
CategoryTheory.Limits.WidePullbackShape.struct._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1}, none = none | null | false |
BiheytingHomClass.map_sdiff | Mathlib.Order.Heyting.Hom | ∀ {F : Type u_6} {α : Type u_7} {β : Type u_8} {inst : BiheytingAlgebra α} {inst_1 : BiheytingAlgebra β}
{inst_2 : FunLike F α β} [self : BiheytingHomClass F α β] (f : F) (a b : α), f (a \ b) = f a \ f b | The proposition that a bi-Heyting homomorphism preserves the difference operation. | true |
WithZero.exp_add | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {M : Type u_4} [inst : AddMonoid M] (a b : M), WithZero.exp (a + b) = WithZero.exp a * WithZero.exp b | null | true |
PresheafOfModules.isColimitFreeYonedaCoproductsCokernelCofork._proof_6 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Generator | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R),
CategoryTheory.Epi
{ X₁ := (CategoryTheory.Limits.kernel M.fromFreeYonedaCoproduct).freeYonedaCoproduct, X₂ := M.freeYonedaCoproduct,
X₃ := M, f := M.toFreeYonedaCoproduct, g :=... | null | false |
Subtype.map_eq | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} {f g : α → β} (h₁ : ∀ (a : α), p a → q (f a))
(h₂ : ∀ (a : α), p a → q (g a)) {x y : Subtype p}, Subtype.map f h₁ x = Subtype.map g h₂ y ↔ f ↑x = g ↑y | null | true |
nonZeroDivisors.associated_coe._simp_1 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a b : ↥(nonZeroDivisors M₀)}, Associated ↑a ↑b = Associated a b | null | false |
measurableSMul₂_of_add | Mathlib.MeasureTheory.Group.Arithmetic | ∀ (M : Type u_2) [inst : Add M] [inst_1 : MeasurableSpace M] [MeasurableAdd₂ M], MeasurableVAdd₂ M M | null | true |
CompHaus.toCondensed | Mathlib.Condensed.Functors | CompHaus → CondensedSet | Dot notation for the value of `compHausToCondensed`. | true |
Vector.forall_getElem | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {p : α → Prop}, (∀ (i : ℕ) (h : i < n), p xs[i]) ↔ ∀ a ∈ xs, p a | null | true |
FractionalIdeal.isPrincipal_of_isPrincipal_num | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] [IsDomain R] (I : FractionalIdeal (nonZeroDivisors R) (FractionRing R)),
Submodule.IsPrincipal I.num → (↑I).IsPrincipal | If the numerator ideal of a fractional ideal is principal, then so is the fractional ideal. | true |
CategoryTheory.StructuredArrow.commaMapEquivalenceInverse_obj | Mathlib.CategoryTheory.Comma.StructuredArrow.CommaMap | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor C T}
{R : CategoryTheory.Functor D T} {C' : Type u₄} [inst_3 : CategoryTheory.Category.{v₄, u₄} C'] {D' : Ty... | null | true |
IsCauSeq.cauchy₃ | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] {abv : β → α} [IsAbsoluteValue abv] {f : ℕ → β},
IsCauSeq abv f → ∀ {ε : α}, 0 < ε → ∃ i, ∀ j ≥ i, ∀ k ≥ j, abv (f k - f j) < ε | null | true |
Std.DHashMap.getKeyD_union_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α] {k fallback : α}, k ∉ m₂ → (m₁ ∪ m₂).getKeyD k fallback = m₁.getKeyD k fallback | null | true |
Lean.Parser.Term.macroArg | Lean.Parser.Term | Lean.Parser.Parser | null | true |
Std.TreeSet.Raw.get?_eq_some_get | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α} (h' : a ∈ t), t.get? a = some (t.get a h') | null | true |
CategoryTheory.Limits.PullbackCone.flipIsLimit._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.PullbackCone g f), CategoryTheory.CategoryStruct.comp (ht.lift s.flip) t.fst = s.snd | null | false |
_private.Lean.Elab.Do.Basic.0.Lean.Elab.Do.elabDoElemFns.match_1 | Lean.Elab.Do.Basic | (motive : Lean.Exception → Sort u_1) →
(ex : Lean.Exception) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) →
((x : Lean.Exception) → motive x) → motive ex | null | false |
ENNReal.instAddCommMonoidWithOne | Mathlib.Data.ENNReal.Basic | AddCommMonoidWithOne ENNReal | null | true |
_private.Lean.Meta.Injective.0.Lean.Meta.mkInjectiveTheoremValue | Lean.Meta.Injective | Lean.Name → Lean.Expr → Lean.MetaM Lean.Expr | null | true |
CategoryTheory.Bicategory.iterated_mateEquiv_conjugateEquiv_symm | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f₁ : a ⟶ c} {u₁ : c ⟶ a} {f₂ : b ⟶ d} {u₂ : d ⟶ b}
{l₁ : a ⟶ b} {r₁ : b ⟶ a} {l₂ : c ⟶ d} {r₂ : d ⟶ c} (adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂) (adj₃ : CategoryTheory.Bicategory.Adjuncti... | null | true |
Lean.Lsp.SignatureHelpParams.context? | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureHelpParams → Option Lean.Lsp.SignatureHelpContext | null | true |
CategoryTheory.TwistShiftData.z_zero_left | Mathlib.CategoryTheory.Shift.Twist | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type w} [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (t : CategoryTheory.TwistShiftData C A) (b : A), t.z 0 b = 1 | null | true |
Lean.IR.Expr.ctor.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) →
t.ctorIdx = 0 → ((i : Lean.IR.CtorInfo) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.ctor i ys)) → motive t | null | false |
_private.Mathlib.MeasureTheory.Integral.DivergenceTheorem.0.MeasureTheory.integral_divergence_prod_Icc_of_hasFDerivAt_off_countable_of_le._abel_1_1 | Mathlib.MeasureTheory.Integral.DivergenceTheorem | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (f g : ℝ × ℝ → E) (a b : ℝ × ℝ),
((∫ (y : ℝ) in Set.Icc a.2 b.2, f (b.1, y)) - ∫ (y : ℝ) in Set.Icc a.2 b.2, f (a.1, y)) +
((∫ (x : ℝ) in Set.Icc a.1 b.1, g (x, b.2)) - ∫ (x : ℝ) in Set.Icc a.1 b.1, g (x, a.2)) =
(((∫ (x : ℝ) in Set.I... | null | false |
Fin.natAddLEFunctor._proof_4 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n k l : ℕ}, k + l ≤ n → ∀ i < l + 1, k + i < n + 1 | null | false |
USize.not_inj | Init.Data.UInt.Bitwise | ∀ {a b : USize}, ~~~a = ~~~b ↔ a = b | null | true |
LinearOrderedCommGroupWithZero.discrete_iff_not_denselyOrdered | Mathlib.GroupTheory.ArchimedeanDensely | ∀ (G : Type u_2) [inst : LinearOrderedCommGroupWithZero G] [Nontrivial Gˣ] [MulArchimedean G],
Nonempty (G ≃*o WithZero (Multiplicative ℤ)) ↔ ¬DenselyOrdered G | Any nontrivial (has other than 0 and 1) linearly ordered mul-archimedean group with zero is
either isomorphic (and order-isomorphic) to `ℤᵐ⁰`, or is densely ordered, exclusively | true |
Real.exp_approx_end' | Mathlib.Analysis.Complex.Exponential | ∀ {n : ℕ} {x a b : ℝ} (m : ℕ),
n + 1 = m →
∀ (rm : ℝ),
↑m = rm →
|x| ≤ 1 →
|1 - a| ≤ b - |x| / rm * ((rm + 1) / rm) → |Real.exp x - Real.expNear n x a| ≤ |x| ^ n / ↑n.factorial * b | null | true |
_private.Mathlib.Data.Seq.Computation.0.Computation.LiftRelAux.match_1.splitter | Mathlib.Data.Seq.Computation | {α : Type u_1} →
{β : Type u_2} →
(motive : α ⊕ Computation α → β ⊕ Computation β → Sort u_3) →
(x : α ⊕ Computation α) →
(x_1 : β ⊕ Computation β) →
((a : α) → (b : β) → motive (Sum.inl a) (Sum.inl b)) →
((a : α) → (cb : Computation β) → motive (Sum.inl a) (Sum.inr cb)) →
... | null | true |
ite_nonpos | Mathlib.Algebra.Notation.Lemmas | ∀ {α : Type u_1} [inst : Zero α] {p : Prop} [inst_1 : Decidable p] {a b : α} [inst_2 : LE α],
a ≤ 0 → b ≤ 0 → (if p then a else b) ≤ 0 | null | true |
Part.get_eq_of_mem | Mathlib.Data.Part | ∀ {α : Type u_1} {o : Part α} {a : α}, a ∈ o → ∀ (h' : o.Dom), o.get h' = a | null | true |
DirectLimit.lift_injective | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} [inst : Preorder ι] {F : ι → Type u_4} {T : ⦃i j : ι⦄ → i ≤ j → Sort u_8}
(f : (i j : ι) → (h : i ≤ j) → T h) [inst_1 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T h) (F i) (F j)]
[inst_2 : DirectedSystem F fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] {C : Sort u_9}
(ih : (i : ι) → F i → ... | null | true |
Std.Sat.AIG.relabel.eq_1 | Std.Sat.AIG.Relabel | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {β : Type} [inst_2 : Hashable β] [inst_3 : DecidableEq β]
(r : α → β) (aig : Std.Sat.AIG α),
Std.Sat.AIG.relabel r aig =
{ decls := Array.map (Std.Sat.AIG.Decl.relabel r) aig.decls, cache := Std.Sat.AIG.Cache.empty, hdag := ⋯,
hzero := ⋯, hconst :=... | null | true |
_private.Std.Http.Data.URI.Encoding.0.Std.Http.URI.hexDigit_isHexDigit._proof_1_1 | Std.Http.Data.URI.Encoding | ∀ {x : UInt8}, x.toNat < 16 → x.toNat < 10 → ¬48 ≤ x.toNat + 48 → False | null | false |
FreeAlgebra.star_ι | Mathlib.Algebra.Star.Free | ∀ {R : Type u_1} [inst : CommSemiring R] {X : Type u_2} (x : X), star (FreeAlgebra.ι R x) = FreeAlgebra.ι R x | null | true |
UniformSpace.ball | Mathlib.Topology.UniformSpace.Defs | {β : Type ub} → β → Set (β × β) → Set β | The ball around `(x : β)` with respect to `(V : Set (β × β))`. Intended to be
used for `V ∈ 𝓤 β`, but this is not needed for the definition. Recovers the
notions of metric space ball when `V = {p | dist p.1 p.2 < r }`. | true |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.unfold?.unfoldDeclToUnfold?.match_1 | Lean.Meta.Tactic.Simp.Main | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((cinfo : Lean.ConstantInfo) → motive (some cinfo)) → ((x : Option Lean.ConstantInfo) → motive x) → motive x | null | false |
CategoryTheory.Precoverage.Saturate.below.pullback | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.Precoverage C}
{motive : (X : C) → (a : CategoryTheory.Sieve X) → J.Saturate X a → Prop} (X : C) (S : CategoryTheory.Sieve X)
(a : J.Saturate X S) (Y : C) (f : Y ⟶ X),
CategoryTheory.Precoverage.Saturate.below a → motive X S a → Ca... | null | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter._proof_6 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2}, Std.DTreeMap.Internal.Impl.leaf.size ≤ Std.DTreeMap.Internal.Impl.leaf.size + 1 | null | false |
Std.DTreeMap.Raw.containsThenInsertIfNew_snd | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k}, (t.containsThenInsertIfNew k v).2 = t.insertIfNew k v | null | true |
CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono | Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{R₁ R₂ : CategoryTheory.ComposableArrows C 3} (φ : R₁ ⟶ R₂),
R₁.Exact →
R₂.Exact →
CategoryTheory.Epi
(CategoryTheory.ComposableArrows.app' φ 0 CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono'._... | null | true |
UInt16.ne_not_self | Init.Data.UInt.Bitwise | ∀ {a : UInt16}, a ≠ ~~~a | null | true |
CategoryTheory.Under.pushout._proof_2 | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushoutsAlong f] (x : CategoryTheory.Under X) {x' : CategoryTheory.Under X}
{u : x ⟶ x'},
CategoryTheory.CategoryStruct.comp x.hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Under... | null | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord.0.NumberField.mixedEmbedding.volume_eq_two_pi_pow_mul_integral._simp_1_3 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n + n = 2 * n | null | false |
Module.AEval.restrict_equiv_mapSubmodule._proof_2 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_2} {A : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (p : Submodule R M) (hp : p ∈ ((Algebra.lsmul R R M) a).invtSubmodule) (x : ↥p),
(Module... | null | false |
Aesop.handleNonfatalError | Aesop.Search.Main | {Q : Type} → [inst : Aesop.Queue Q] → Lean.MessageData → Aesop.SearchM Q (Array Lean.MVarId) | null | true |
Std.Rxo.IsAlwaysFinite.mk | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LT α],
(∀ (init hi : α), ∃ n, (Std.PRange.succMany? n init).elim True fun x => ¬x < hi) → Std.Rxo.IsAlwaysFinite α | null | true |
Std.DHashMap.Internal.Raw₀.find?_toList_eq_some_iff_get?_eq_some | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α],
(↑m).WF → ∀ {k : α} {v : β k}, List.find? (fun x => x.fst == k) (↑m).toList = some ⟨k, v⟩ ↔ m.get? k = some v | null | true |
HomotopicalAlgebra.RightHomotopyClass.precomp_bijective_of_weakEquivalence | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C} (Z : C)
[HomotopicalAlgebra.IsFibrant Z] (f : X ⟶ Y) [HomotopicalAlgebra.IsCofibrant X] [HomotopicalAlgebra.IsCofibrant Y]
[HomotopicalAlgebra.WeakEquivalence f], Function.Bijective fun g => g.precomp f | null | true |
PartitionOfUnity.exists_finset_nhds | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] (ρ : PartitionOfUnity ι X) (x₀ : X),
∃ I, ∀ᶠ (x : X) in nhds x₀, ∑ i ∈ I, (ρ i) x = 1 ∧ (Function.support fun x_1 => (ρ x_1) x) ⊆ ↑I | null | true |
SetRel.isCover_univ._simp_1 | Mathlib.Data.Rel.Cover | ∀ {X : Type u_1} {s N : Set X}, SetRel.IsCover Set.univ s N = (s.Nonempty → N.Nonempty) | null | false |
SeparationQuotient.liftNormedAddGroupHomEquiv._proof_1 | Mathlib.Analysis.Normed.Group.SeparationQuotient | ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] {N : Type u_2} [inst_1 : SeminormedAddCommGroup N]
(g : NormedAddGroupHom (SeparationQuotient M) N) (x : M), ‖x‖ = 0 → (g.comp SeparationQuotient.normedMk) x = 0 | null | false |
UInt64.toFin_not | Init.Data.UInt.Bitwise | ∀ (a : UInt64), (~~~a).toFin = a.toFin.rev | null | true |
CategoryTheory.BraidedCategory.ofBifunctor | Mathlib.CategoryTheory.Monoidal.Braided.Multifunctor | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
(β : CategoryTheory.MonoidalCategory.curriedTensor C ≅ (CategoryTheory.MonoidalCategory.curriedTensor C).flip) →
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.curried... | Given a braiding `β : curriedTensor C ≅ (curriedTensor C).flip` as a natural isomorphism between
bifunctors, and the two equalities `hexagon_forward` and `hexagon_reverse` of natural
transformations between trifunctors, we obtain a braided category structure.
| true |
ArchimedeanClass.mk.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (a : M),
ArchimedeanClass.mk a = toAntisymmetrization (fun x1 x2 => x1 ≤ x2) (ArchimedeanOrder.of a) | null | true |
LocallyFiniteSupport.locallyFinite_support | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_2} [inst_1 : Zero Y] (f : X → Y),
LocallyFiniteSupport f → LocallyFinite fun s => {↑s} | null | true |
wrapped._@.Mathlib.Analysis.Calculus.FDeriv.Defs.639413672._hygCtx._hyg.8 | Mathlib.Analysis.Calculus.FDeriv.Defs | Subtype (Eq definition✝) | null | false |
UniformOnFun.hasBasis_nhds_zero_of_basis | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {G : Type u_2} {ι : Type u_3} [inst : AddGroup G] [inst_1 : UniformSpace G] [IsUniformAddGroup G]
(𝔖 : Set (Set α)),
𝔖.Nonempty →
DirectedOn (fun x1 x2 => x1 ⊆ x2) 𝔖 →
∀ {p : ι → Prop} {b : ι → Set G},
(nhds 0).HasBasis p b →
(nhds 0).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p... | null | true |
USize.toNat.eq_1 | Init.Data.UInt.Lemmas | ∀ (n : USize), n.toNat = n.toBitVec.toNat | null | true |
Nat.cast_list_sum | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {R : Type u_4} [inst : AddMonoidWithOne R] (s : List ℕ), ↑s.sum = (List.map Nat.cast s).sum | null | true |
MonoidHom.instCommMonoid._proof_6 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : CommMonoid N] (a b : M →* N), a * b = b * a | null | false |
Std.TreeSet.Raw.getD_ofList_of_mem | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {l : List α} {k k' fallback : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeSet.Raw.ofList l cmp).getD k' fallback = k | null | true |
Std.ExtDTreeMap.forIn.congr_simp | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {δ : Type w} {m : Type w → Type w₂} [inst : Monad m]
[inst_1 : LawfulMonad m] [inst_2 : Std.TransCmp cmp] (f f_1 : (a : α) → β a → δ → m (ForInStep δ)),
f = f_1 →
∀ (init init_1 : δ),
init = init_1 →
∀ (t t_1 : Std.ExtDTreeMap α β cmp),
... | null | true |
isConjRoot_algHom_iff | Mathlib.FieldTheory.Minpoly.IsConjRoot | ∀ {R : Type u_1} {B : Type u_6} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B] {A : Type u_7}
[inst_3 : DivisionRing A] [inst_4 : Algebra R A] [Nontrivial B] {x y : A} (f : A →ₐ[R] B),
IsConjRoot R (f x) (f y) ↔ IsConjRoot R x y | If `y` is a conjugate root of `x` in some division ring and `f` is an `R`-algebra homomorphism, then
`f y` is a conjugate root of `f x`.
| true |
Nat.instMeasurableSingletonClass | Mathlib.MeasureTheory.MeasurableSpace.Instances | MeasurableSingletonClass ℕ | null | true |
UniformConvergenceCLM.piEquivL._proof_9 | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ (𝕜 : Type u_1) [inst : NormedField 𝕜] {ι : Type u_2} (F : ι → Type u_3) [inst_1 : (i : ι) → AddCommGroup (F i)]
[inst_2 : (i : ι) → Module 𝕜 (F i)], SMulCommClass 𝕜 𝕜 ((i : ι) → F i) | null | false |
_private.Mathlib.Analysis.Convex.Deriv.0.StrictMonoOn.exists_slope_lt_deriv._simp_1_1 | Mathlib.Analysis.Convex.Deriv | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [MulPosReflectLT G₀] {a b c : G₀},
0 < c → (b / c < a) = (b < a * c) | null | false |
AlgebraicGeometry.IsNoetherian.mk | Mathlib.AlgebraicGeometry.Noetherian | ∀ {X : AlgebraicGeometry.Scheme} [toIsLocallyNoetherian : AlgebraicGeometry.IsLocallyNoetherian X]
[toCompactSpace : CompactSpace ↥X], AlgebraicGeometry.IsNoetherian X | null | true |
FirstOrder.Field.FieldAxiom.existsPairNE.sizeOf_spec | Mathlib.ModelTheory.Algebra.Field.Basic | sizeOf FirstOrder.Field.FieldAxiom.existsPairNE = 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.