name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Order.Category.PartOrdEmb.0.PartOrdEmb.Hom.ext.match_1 | Mathlib.Order.Category.PartOrdEmb | ∀ {X Y : PartOrdEmb} (motive : X.Hom Y → Prop) (h : X.Hom Y), (∀ (hom' : ↑X ↪o ↑Y), motive { hom' := hom' }) → motive h | null | false |
CategoryTheory.Functor.coconeTypesEquiv_symm_apply_ι | Mathlib.CategoryTheory.Limits.Types.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J (Type u))
(c : CategoryTheory.Limits.Cocone F) (j : J) (a : F.obj j),
(F.coconeTypesEquiv.symm c).ι j a = (CategoryTheory.ConcreteCategory.hom (c.ι.app j)) a | null | true |
InfiniteGalois.normalAutEquivQuotient._proof_3 | Mathlib.FieldTheory.Galois.Infinite | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(H : ClosedSubgroup Gal(K/k)), IsScalarTower k (↥(IntermediateField.fixedField ↑H)) K | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.artanh_eq_half_log._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ {x : ℝ}, x ∈ Set.Icc (-1) 1 → 0 ≤ 1 + x | null | false |
_private.Mathlib.Topology.Semicontinuity.Hemicontinuity.0.LowerHemicontinuousAt.of_sequences.match_1_1 | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_2} {β : Type u_1} {f : α → Set β} {x₀ : α} (U : Set β) (motive : (f x₀ ∩ U).Nonempty → Prop)
(h : (f x₀ ∩ U).Nonempty), (∀ (y₀ : β) (hy₀f : y₀ ∈ f x₀) (hy₀U : y₀ ∈ U), motive ⋯) → motive h | null | false |
ModelWithCorners.compl_boundary | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M],
(ModelWithCorners.boundary M)ᶜ = Mod... | The interior is the complement of the boundary. | true |
Std.Rii.mk.sizeOf_spec | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} [inst : SizeOf α], sizeOf *...* = 1 | null | true |
AddCommMonCat.coyonedaObjIsoForget._proof_1 | Mathlib.Algebra.Category.MonCat.ForgetCorepresentable | ∀ {X Y : AddCommMonCat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.coyoneda.obj (Opposite.op ↧(ULift.{u_1, 0} ℕ))).map f)
(CategoryTheory.ConcreteCategory.homEquiv.trans (uliftMultiplesHom ↑Y).symm).toIso.hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ConcreteCategory.h... | null | false |
CharTwo.add_eq_iff_eq_add | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : NonAssocSemiring R] [CharP R 2] {a b c : R}, a + b = c ↔ a = c + b | null | true |
WeierstrassCurve.Jacobian.dblU_ne_zero_of_Y_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P Q : Fin 3 → F},
W.Nonsingular P →
P 2 ≠ 0 →
Q 2 ≠ 0 →
P 0 * Q 2 ^ 2 = Q 0 * P 2 ^ 2 →
P 1 * Q 2 ^ 3 = Q 1 * P 2 ^ 3 → P 1 * Q 2 ^ 3 = W.negY Q * P 2 ^ 3 → W.dblU P ≠ 0 | null | true |
MeasureTheory.condExp_stronglyMeasurable_simpleFunc_mul | Mathlib.MeasureTheory.Function.ConditionalExpectation.PullOut | ∀ {Ω : Type u_1} {m mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω},
m ≤ mΩ →
∀ (f : MeasureTheory.SimpleFunc Ω ℝ) {g : Ω → ℝ}, MeasureTheory.Integrable g μ → μ[⇑f * g | m] =ᵐ[μ] ⇑f * μ[g | m] | null | true |
CategoryTheory.Presieve.map.casesOn | Mathlib.CategoryTheory.Sites.Sieves.Functoriality | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X : C} {s : CategoryTheory.Presieve X}
{motive : ⦃Y : D⦄ → (a : Y ⟶ F.obj X) → CategoryTheory.Presieve.map F s a → Prop} ⦃Y : D⦄ {a : Y ⟶ F.obj X}
(t : Category... | null | false |
_private.Mathlib.Topology.Algebra.InfiniteSum.ENNReal.0.Summable.toNNReal._simp_1_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] (a : α), (a ≤ |a|) = True | null | false |
Lean.AttributeImpl._sizeOf_inst | Lean.Attributes | SizeOf Lean.AttributeImpl | null | false |
IsLocalization.map_smul | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] {g : R →+* P}
{T : Submonoid P} {Q : Type u_4} [inst_5 : CommSemiring Q] [inst_6 : Algebra P Q] [inst_7 : IsLocalization T... | null | true |
MulHom.prodMap_def | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {M' : Type u_6} {N' : Type u_7} [inst : Mul M] [inst_1 : Mul N] [inst_2 : Mul M']
[inst_3 : Mul N'] (f : M →ₙ* M') (g : N →ₙ* N'),
f.prodMap g = (f.comp (MulHom.fst M N)).prod (g.comp (MulHom.snd M N)) | null | true |
TopologicalSpace.Opens.inclusion'_top_functor | Mathlib.Topology.Category.TopCat.Opens | ∀ (X : TopCat), ⋯.functor = TopologicalSpace.Opens.map (TopologicalSpace.Opens.inclusionTopIso X).inv | null | true |
Real.two_mul_sin_mul_sin | Mathlib.Analysis.Complex.Trigonometric | ∀ (x y : ℝ), 2 * Real.sin x * Real.sin y = Real.cos (x - y) - Real.cos (x + y) | null | true |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.repr_opow_aux₂._simp_1_7 | Mathlib.SetTheory.Ordinal.Notation | ∀ {x y : ONote}, (x < y) = (x.repr < y.repr) | null | false |
Subgroup.instHasDetOneMapSpecialLinearGroupGeneralLinearGroupMapGL | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | ∀ {n : Type u_1} [inst : Fintype n] [inst_1 : DecidableEq n] {R : Type u_2} [inst_2 : CommRing R] {S : Type u_3}
[inst_3 : CommRing S] [inst_4 : Algebra R S] (Γ : Subgroup (Matrix.SpecialLinearGroup n R)),
(Subgroup.map (Matrix.SpecialLinearGroup.mapGL S) Γ).HasDetOne | null | true |
Std.Sat.AIG.unsat_relabel | Std.Sat.AIG.Relabel | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {β : Type} [inst_2 : Hashable β] [inst_3 : DecidableEq β]
{idx : ℕ} {invert : Bool} {aig : Std.Sat.AIG α} (r : α → β) {hidx : idx < aig.decls.size},
aig.UnsatAt idx invert hidx → (Std.Sat.AIG.relabel r aig).UnsatAt idx invert ⋯ | null | true |
retractionKerCotangentToTensorEquivSection._proof_18 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_3} {P : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R P S],
KaehlerDifferential.kerCotangentToTensor R P S =
↑(LinearEquiv.restrictScalars P (tensorKaehlerQuo... | null | false |
Matrix.instLieRingToLieAlgebra._proof_7 | Mathlib.Algebra.Lie.SerreConstruction | ∀ (R : Type u_1) {B : Type u_2} [inst : CommRing R] (CM : Matrix B B ℤ) [inst_1 : DecidableEq B]
(a : Matrix.ToLieAlgebra R CM), a + 0 = a | null | false |
WittVector.frobenius_zmodp | Mathlib.RingTheory.WittVector.Frobenius | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (x : WittVector p (ZMod p)), WittVector.frobenius x = x | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_union_of_not_mem._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 |
PLift.instNonempty_mathlib | Mathlib.Data.ULift | ∀ {α : Sort u} [Nonempty α], Nonempty (PLift α) | null | true |
_private.Mathlib.Data.ZMod.Basic.0.ZModModule.two_le_char._proof_1_1 | Mathlib.Data.ZMod.Basic | ∀ (n : ℕ), n ≠ 0 → n ≠ 1 → 2 ≤ n | null | false |
Std.Http.Method.propfind.elim | Std.Http.Data.Method | {motive : Std.Http.Method → Sort u} →
(t : Std.Http.Method) → t.ctorIdx = 25 → motive Std.Http.Method.propfind → motive t | null | false |
Nat.factorization_choose_eq_zero_of_lt | Mathlib.Data.Nat.Choose.Factorization | ∀ {p n k : ℕ}, n < p → (n.choose k).factorization p = 0 | null | true |
Nonneg.instIsOrderedModule | Mathlib.Algebra.Order.Nonneg.Module | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : PartialOrder M] [inst_4 : SMulWithZero R M] [hM : IsOrderedModule R M], IsOrderedModule (Nonneg R) M | null | true |
Real.tanh_arsinh | Mathlib.Analysis.SpecialFunctions.Arsinh | ∀ (x : ℝ), Real.tanh (Real.arsinh x) = x / √(1 + x ^ 2) | null | true |
Lean.Literal.type | Lean.Expr | Lean.Literal → Lean.Expr | Return the type of a literal value. | true |
Mathlib.Tactic.Algebra.algebra | Mathlib.Tactic.Algebra.Basic | Lean.ParserDescr | `algebra` solves equalities in the language of algebras: ring operations and scalar
multiplications.
Given a goal which is an equality in a commutative `R`-algebra `A`, `algebra` parses the LHS and
RHS of the goal as polynomial expressions of `A`-atoms with coefficients in some semiring `R`, and
closes the goal if the... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Basic.0.SimpleGraph.Walk.mem_darts_iff_infix_support._proof_1_26 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {u v u' v' : V} {p : G.Walk u v} (w : ℕ),
(∀ (i : ℕ) (h : i + 1 ≤ [u', v'].length), p.support[w + i]? = some [u', v'][i]) →
1 ≤ [u', v'].length → w < p.support.length | null | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionAssocNatIso_hom_app_app_app | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (X X_1 : C) (X_2 : D),
(((CategoryTheory.MonoidalCategory.MonoidalRightActio... | null | true |
Set.Icc_eq_empty_of_lt | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b < a → Set.Icc a b = ∅ | null | true |
Lean.Meta.Grind.closeGoal | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Meta.Grind.GoalM Unit | Closes the current goal using the given proof of `False` and
marks it as inconsistent if it is not already marked so.
| true |
Std.Sat.CNF.Clause.ne_of_mem_of_negate_mem | Std.Sat.CNF.Basic | ∀ {α : Type u_1} {l l' : Std.Sat.Literal α} {c : Std.Sat.CNF.Clause α}, l ∈ c → l' ∉ c → l'.negate ∉ c → l.1 ≠ l'.1 | null | true |
HasFDerivAt.of_isLittleOTVS | Mathlib.Analysis.Calculus.FDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {f' : E →L[𝕜] F} {x : E},
((fun x' => f x' - f x - f' (x' -... | **Alias** of the reverse direction of `hasFDerivAt_iff_isLittleOTVS`. | true |
Mathlib.Tactic.FieldSimp.Sign.div | Mathlib.Tactic.FieldSimp.Lemmas | {v : Lean.Level} →
{M : Q(Type v)} →
(iM : Q(CommGroupWithZero «$M»)) →
(y₁ y₂ : Q(«$M»)) →
(g₁ g₂ : Mathlib.Tactic.FieldSimp.Sign M) →
Lean.MetaM
((G : Mathlib.Tactic.FieldSimp.Sign M) ×
have a := G.expr q(«$y₁» / «$y₂»);
have a_1 := g₂.expr y₂;
... | Given expressions `y₁ y₂ : Q($M)` with specified signs (either + or -), construct a proof that
the quotient of (± `y₁`) and (± `y₂`) (here taking the specified signs) is ± `y₁ / y₂`; return this
proof and the computed sign. | true |
CommRingCat.limitCommRing._aux_1 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J CommRingCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections] →
CommRing ↑(F.comp (CategoryTheory.forget CommRingCat)).sections →
(CategoryTheory.Limit... | null | false |
CategoryTheory.Oplax.StrongTrans.Modification.casesOn | 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} →
{motive : CategoryTheory.Oplax.StrongTrans.Modification η θ → Sort u} →
(t : CategoryTheory.Op... | null | false |
Bipointed.X | Mathlib.CategoryTheory.Category.Bipointed | Bipointed → Type u | The underlying type of a bipointed type. | true |
Std.DTreeMap.Raw.Equiv.getKeyGTD_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
{k fallback : α}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getKeyGTD k fallback = t₂.getKeyGTD k fallback | null | true |
CategoryTheory.Abelian.SpectralObject.isoMapFourδ₁Toδ₀'._auto_1 | Mathlib.Algebra.Homology.SpectralObject.EpiMono | Lean.Syntax | null | false |
CommHopfAlgCat.rec | Mathlib.Algebra.Category.CommHopfAlgCat | {R : Type u} →
[inst : CommRing R] →
{motive : CommHopfAlgCat R → Sort u_1} →
((X : Type v) → [commRing : CommRing X] → [hopfAlgebra : HopfAlgebra R X] → motive ↧X) →
(t : CommHopfAlgCat R) → motive t | null | false |
Subgroup.strictPeriods_eq_zmultiples_one_of_T_mem | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {Γ : Subgroup (Matrix.SpecialLinearGroup (Fin 2) ℤ)},
ModularGroup.T ∈ Γ → (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) Γ).strictPeriods = AddSubgroup.zmultiples 1 | null | true |
AlgebraicGeometry.Scheme.coprodPresheafObjIso._proof_2 | Mathlib.AlgebraicGeometry.Limits | ∀ {X Y : AlgebraicGeometry.Scheme} (U : (X ⨿ Y).Opens),
(AlgebraicGeometry.Scheme.Hom.opensFunctor CategoryTheory.Limits.coprod.inl).obj
((TopologicalSpace.Opens.map CategoryTheory.Limits.coprod.inl.base).obj U) ⊓
(AlgebraicGeometry.Scheme.Hom.opensFunctor CategoryTheory.Limits.coprod.inr).obj
(... | null | false |
SimpleGraph.chromaticNumber_bddBelow | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} {G : SimpleGraph V}, BddBelow {n | G.Colorable n} | null | true |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreOfNat.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {a b : Lean.Expr} {natStructId : ℕ} {lhs rhs : Lean.Meta.Grind.Arith.Linear.LinExpr} {a_1 b_1 : Lean.Expr}
{natStructId_1 : ℕ} {lhs_1 rhs_1 : Lean.Meta.Grind.Arith.Linear.LinExpr},
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreOfNat a b natStructId lhs rhs =
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreOfN... | null | true |
instCommutativeInt64HAnd | Init.Data.SInt.Bitwise | Std.Commutative fun x1 x2 => x1 &&& x2 | null | true |
Group.FG.eq_1 | Mathlib.GroupTheory.Finiteness | ∀ (G : Type u_3) [inst : Group G], Group.FG G = IsMulFG G | null | true |
CategoryTheory.MorphismProperty.CostructuredArrow.isoMk._auto_1 | Mathlib.CategoryTheory.MorphismProperty.Comma | Lean.Syntax | null | false |
ModularForm.qExpansion_inj | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {h : ℝ},
0 < h →
h ∈ Γ.strictPeriods →
∀ {k : ℤ} {f g : ModularForm Γ k}, UpperHalfPlane.qExpansion h ⇑f = UpperHalfPlane.qExpansion h ⇑g ↔ f = g | null | true |
Equiv.equivCongr_refl_left | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (bg : β ≃ γ) (e : α ≃ β), ((Equiv.refl α).equivCongr bg) e = e.trans bg | null | true |
IsClosedMap | Mathlib.Topology.Defs.Basic | {X : Type u} → {Y : Type v} → [TopologicalSpace X] → [TopologicalSpace Y] → (X → Y) → Prop | A map `f : X → Y` is said to be a *closed map*,
if the image of any closed `U : Set X` is closed in `Y`. | true |
ContinuousMultilinearMap.seminorm._proof_3 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_1) (G : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G], SMulCommClass 𝕜 𝕜 G | null | false |
GaloisCoinsertion.liftSemilatticeSup.eq_1 | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : α → β} {u : β → α} [inst : PartialOrder β] [inst_1 : SemilatticeSup α]
(gi : GaloisCoinsertion u l),
gi.liftSemilatticeSup =
{ toPartialOrder := inst, sup := fun a b => gi.choice (u a ⊔ u b) ⋯, le_sup_left := ⋯, le_sup_right := ⋯,
sup_le := ⋯ } | null | true |
SemilatticeSup.mk.noConfusion | Mathlib.Order.Defs.Lattice | {α : Type u} →
{P : Sort u_1} →
{toPartialOrder : PartialOrder α} →
{sup : α → α → α} →
{le_sup_left : ∀ (a b : α), a ≤ sup a b} →
{le_sup_right : ∀ (a b : α), b ≤ sup a b} →
{sup_le : ∀ (a b c : α), a ≤ c → b ≤ c → sup a b ≤ c} →
{toPartialOrder' : PartialOrder α... | null | false |
HasSum.nat_add_neg_add_one | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] {m : M} {f : ℤ → M},
HasSum f m → HasSum (fun n => f ↑n + f (-(↑n + 1))) m | null | true |
ENNReal.toReal_ofReal_eq_iff._simp_1 | Mathlib.Basic.ENNReal.Basic | ∀ {a : ℝ}, ((ENNReal.ofReal a).toReal = a) = (0 ≤ a) | null | false |
_private.Batteries.Data.Random.MersenneTwister.0.Batteries.Random.MersenneTwister.Config.init.loop._unsafe_rec | Batteries.Data.Random.MersenneTwister | (cfg : Batteries.Random.MersenneTwister.Config) →
BitVec cfg.wordSize →
(v : Array (BitVec cfg.wordSize)) → v.size ≤ cfg.stateSize → Vector (BitVec cfg.wordSize) cfg.stateSize | null | false |
FirstOrder.Language.BoundedFormula.listDecode._proof_5 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u_2} (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ))
(x :
(y : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)) →
InvImage (fun x1 x2 => x1 < x2) (fun x => x.length) y (Sum.inr (Sum.inr 0) :: l) →
List ((n : ℕ) × L.Bound... | null | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.insertMany.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {ρ : Type w} [inst : ForIn Id ρ ((a : α) × β a)] [inst_1 : BEq α] [inst_2 : Hashable α]
(m : Std.DHashMap.Internal.Raw₀ α β) (l : ρ),
m.insertMany l =
(have r := ⟨m, ⋯⟩;
do
let __s ←
forIn l r fun x __s =>
let r := __s;
match x with
... | null | true |
ProofWidgets.RefreshComponent.instRpcEncodableVersionedHtml.dec._@.ProofWidgets.Component.RefreshComponent.4220679497._hygCtx._hyg.1 | ProofWidgets.Component.RefreshComponent | Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) ProofWidgets.RefreshComponent.VersionedHtml | null | false |
_private.Lean.Data.LBool.0.Lean.LBool.and._sparseCasesOn_1 | Lean.Data.LBool | {motive : Lean.LBool → Sort u} →
(t : Lean.LBool) → motive Lean.LBool.true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
BitVec.toNat_ofInt | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (i : ℤ), (BitVec.ofInt n i).toNat = (i % ↑(2 ^ n)).toNat | null | true |
Bundle.Trivialization.pullback._proof_4 | Mathlib.Topology.FiberBundle.Constructions | ∀ {B : Type u_4} {F : Type u_3} {E : B → Type u_1} {B' : Type u_2} [inst : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_1 : TopologicalSpace F] [inst_2 : TopologicalSpace B] [inst_3 : ∀ (_b : B), Nonempty (E _b)] {K : Type u_5}
[inst_4 : FunLike K B' B] (e : Bundle.Trivialization F Bundle.TotalSpace.proj) (f : K... | null | false |
MeasureTheory.MeasurePreserving.withDensity_rnDeriv | Mathlib.Dynamics.Ergodic.RadonNikodym | ∀ {X : Type u_1} {m : MeasurableSpace X} {μ ν : MeasureTheory.Measure X} [MeasureTheory.IsFiniteMeasure μ]
[MeasureTheory.SigmaFinite ν] {f : X → X},
MeasureTheory.MeasurePreserving f μ μ →
MeasureTheory.MeasurePreserving f ν ν →
MeasureTheory.MeasurePreserving f (ν.withDensity (μ.rnDeriv ν)) (ν.withDensi... | The absolutely continuous part of a finite invariant measure of a self-map
with respect to a σ-finite invariant measure is an invariant measure. | true |
Countable.LindelofSpace | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] [Countable X], LindelofSpace X | Countable topological spaces are Lindelof. | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Basic.0.Complex.Gamma_integrand_deriv_integrable_A | Mathlib.Analysis.SpecialFunctions.Gamma.Basic | ∀ {s : ℂ},
0 < s.re → ∀ {X : ℝ}, 0 ≤ X → IntervalIntegrable (fun x => -(↑(Real.exp (-x)) * ↑x ^ s)) MeasureTheory.volume 0 X | null | true |
Stream'.WSeq.LiftRelO | Mathlib.Data.WSeq.Relation | {α : Type u} →
{β : Type v} →
(α → β → Prop) →
(Stream'.WSeq α → Stream'.WSeq β → Prop) → Option (α × Stream'.WSeq α) → Option (β × Stream'.WSeq β) → Prop | lift a relation to a relation over weak sequences | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1to1.tr_respects._proof_1_22 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_3} {Λ : Type u_2} {σ : Type u_1} {n : ℕ} {enc : Γ → List.Vector Bool n} (dec : List.Vector Bool n → Γ)
(M : Λ → Turing.TM1.Stmt Γ Λ σ) [inst : Inhabited Γ] {enc0 : enc default = List.Vector.replicate n false}
(p : Γ → σ → Bool) (q₁ q₂ : Turing.TM1.Stmt Γ Λ σ),
(∀ (v : σ) (L R : Turing.ListBlank Γ),
... | null | false |
neg_le_of_abs_le | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] {a b : G}, |a| ≤ b → -b ≤ a | null | true |
Filter.ker_principal | Mathlib.Order.Filter.Ker | ∀ {α : Type u_2} (s : Set α), (Filter.principal s).ker = s | null | true |
CategoryTheory.Preregular.recOn | Mathlib.CategoryTheory.Sites.Coherent.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Preregular C → Sort u} →
(t : CategoryTheory.Preregular C) →
((exists_fac :
∀ {X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ Y) [CategoryTheory.EffectiveEpi g],
∃ W h,
∃ (_ : C... | null | false |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.nextn.eq_def | Batteries.Data.String.Lemmas | ∀ (x : String.Legacy.Iterator) (x_1 : ℕ),
x.nextn x_1 =
match x, x_1 with
| it, 0 => it
| it, i.succ => it.next.nextn i | null | true |
CategoryTheory.ShortComplex.Homotopy.ext_iff | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.Preadditive C}
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} {x y : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂},
x = y ↔ x.h₀ = y.h₀ ∧ x.h₁ = y.h₁ ∧ x.h₂ = y.h₂ ∧ x.h₃ = y.h₃ | null | true |
MeasureTheory.JordanDecomposition.posPart_finite | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_2} [inst : MeasurableSpace α] (self : MeasureTheory.JordanDecomposition α),
MeasureTheory.IsFiniteMeasure self.posPart | null | true |
IsEvenlyCovered.toTrivialization'._proof_18 | Mathlib.Topology.Covering.Basic | ∀ {E : Type u_3} {X : Type u_1} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {I : Type u_2}
[inst_2 : TopologicalSpace I] {x : X} [inst_3 : Nonempty I] (U : Set X)
(x_1 : x ∈ U ∧ IsOpen U ∧ IsOpen (f ⁻¹' U) ∧ ∃ H, ∀ (x : ↑(f ⁻¹' U)), ↑(H x).1 = f ↑x) (H : ↑(f ⁻¹' U) ≃ₜ ↑U × I),
(∀ (x : ↑(... | null | false |
Std.LawfulBEqCmp.lawfulBEq | Init.Data.Order.Ord | ∀ {α : Type u} [inst : BEq α] {cmp : α → α → Ordering} [inst_1 : Std.LawfulBEqCmp cmp] [Std.LawfulEqCmp cmp],
LawfulBEq α | null | true |
String.Legacy.Iterator.forward._sunfold | Init.Data.String.Iterator | String.Legacy.Iterator → ℕ → String.Legacy.Iterator | null | false |
LieGroup.«term𝑳» | Mathlib.Geometry.Manifold.Algebra.Monoid | Lean.ParserDescr | Left multiplication by `g`. It is meant to mimic the usual notation in Lie groups.
Used mostly through the notation `𝑳`.
Lemmas involving `smoothLeftMul` with the notation `𝑳` usually use `L` instead of `𝑳` in the
names. | true |
Lean.Grind.ConfigInteractive.hom._inherited_default | Init.Grind.Config | Bool | null | false |
Lean.Elab.Term.ElabElimInfo.noConfusionType | Lean.Elab.App | Sort u → Lean.Elab.Term.ElabElimInfo → Lean.Elab.Term.ElabElimInfo → Sort u | null | false |
CategoryTheory.Oplax.OplaxTrans.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} [inst_2 : SizeOf B] [inst_3 : SizeOf C] (app : (a : B) → F.obj a ⟶ G.obj a)
(naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (... | null | true |
Int.lcm_mul_right | Init.Data.Int.Gcd | ∀ (m n k : ℤ), (m * n).lcm (k * n) = m.lcm k * n.natAbs | null | true |
SimpleGraph.uniqueOfSubsingleton._proof_1 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u_1} [Subsingleton V] (G : SimpleGraph V), G = ⊥ | null | false |
PresheafOfModules.instMonoidalCompOppositeCommRingCatRingCatForget₂RingHomCarrierCarrierOpPushforward₀OfCommRingCat._proof_2 | Mathlib.Algebra.Category.ModuleCat.Presheaf.PushforwardZeroMonoidal | ∀ {C : Type u_4} {D : Type u_3} [inst : CategoryTheory.Category.{u_5, u_4} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ CommRingCat)
{X Y : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))}
(X' : PresheafOfModules (R.c... | null | false |
normalClosure.instIsScalarTowerSubtypeMemIntermediateFieldNormalClosure | Mathlib.FieldTheory.Normal.Closure | ∀ (F : Type u_1) (K : Type u_2) (L : Type u_3) [inst : Field F] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra F K] [inst_4 : Algebra F L] [inst_5 : Algebra K L] [inst_6 : IsScalarTower F K L],
IsScalarTower F K ↥(IntermediateField.normalClosure F K L) | null | true |
Aesop.RuleSetNameFilter.casesOn | Aesop.RuleSet.Filter | {motive : Aesop.RuleSetNameFilter → Sort u} →
(t : Aesop.RuleSetNameFilter) → ((ns : Array Aesop.RuleSetName) → motive { ns := ns }) → motive t | null | false |
CategoryTheory.ComposableArrows.fourδ₄Toδ₃_app_one | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₃₄ : i₂ ⟶ i₄) (h₃₄ : CategoryTheory.CategoryStruct.comp f₃ f₄ = f₃₄),
(CategoryTheory.ComposableArrows.fourδ₄Toδ₃ f₁ f₂ f₃ f₄ f₃₄ h₃₄).app 1 =
CategoryTheory.Category... | null | true |
_private.Mathlib.GroupTheory.Descent.0.CommGroup.finite_torsion_of_descent'._proof_1_2 | Mathlib.GroupTheory.Descent | (3 + 1).AtLeastTwo | null | false |
Std.Rco.size_eq_if_roo | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rco α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxo.HasSize α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[Std.Rxo.IsAlwaysFinite α] [Std.Rxo.LawfulHasSize α],
r.size = if r.lower < r.upper then (r.lowe... | null | true |
_private.Mathlib.Algebra.Ring.BooleanRing.0.BooleanRing.mul_add_mul._abel_1_1 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (a b : α), a + a * b + (b * a + b) = a + b + (a * b + b * a) | null | false |
Std.Http.Protocol.H1.instBEqError.beq | Std.Http.Protocol.H1.Error | Std.Http.Protocol.H1.Error → Std.Http.Protocol.H1.Error → Bool | null | true |
_private.Batteries.Util.LibraryNote.0.Batteries.Util.LibraryNote.initFn._@.Batteries.Util.LibraryNote.1081991270._hygCtx._hyg.2 | Batteries.Util.LibraryNote | IO
(Lean.SimplePersistentEnvExtension Batteries.Util.LibraryNote.LibraryNoteEntry
(Array Batteries.Util.LibraryNote.LibraryNoteEntry)) | null | false |
ByteArray.Iterator.mk.sizeOf_spec | Init.Data.ByteArray.Basic | ∀ (array : ByteArray) (idx : ℕ), sizeOf { array := array, idx := idx } = 1 + sizeOf array + sizeOf idx | null | true |
Ideal.Quotient.algebra._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R₁ : Type u_1) {A : Type u_2} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A],
IsScalarTower R₁ A A | null | false |
le_total_of_codirected | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] {r v₁ v₂ : α},
r ≤ v₁ → r ≤ v₂ → v₁ ≤ v₂ ∨ v₂ ≤ v₁ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.