name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
NonUnitalSubsemiring.instInhabited | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {R : Type u} → [inst : NonUnitalNonAssocSemiring R] → Inhabited (NonUnitalSubsemiring R) | null | true |
Nat.dist_cast_real | Mathlib.Topology.Instances.Nat | ∀ (x y : ℕ), dist ↑x ↑y = dist x y | null | true |
Std.Tactic.BVDecide.LRAT.Internal.State.unsat_of_propagateHints_eq_conflict | Std.Tactic.BVDecide.LRAT.Internal.Rup | ∀ {s : Std.Tactic.BVDecide.LRAT.Internal.State} {assign : Std.Tactic.BVDecide.LRAT.Internal.Assignment}
{hints : Array ℕ},
s.propagateHints assign hints = Std.Tactic.BVDecide.LRAT.Internal.PropagateResult.conflict →
(s.toCNF ++ assign.toCNF).Unsat | null | true |
UInt32.add_right_inj._simp_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32} (c : UInt32), (c + a = c + b) = (a = b) | null | false |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreOfNat.injEq | 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.coreOf... | null | true |
LocallyConstant.charFn_eq_one | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : MulZeroOneClass Y] {U : Set X} [Nontrivial Y]
(x : X) (hU : IsClopen U), (LocallyConstant.charFn Y hU) x = 1 ↔ x ∈ U | null | true |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.mkAndThenSeq._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Split | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
MulAction.IsPretransitive.t1Space_iff | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} (G : Type u_4) [inst : TopologicalSpace α] [inst_1 : Group G] [inst_2 : MulAction G α]
[ContinuousConstSMul G α] (x : α) [MulAction.IsPretransitive G α], T1Space α ↔ IsClosed {x} | null | true |
FreeAddMonoid.length_eq_one | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {a : FreeAddMonoid α}, a.length = 1 ↔ ∃ m, a = FreeAddMonoid.of m | null | true |
PNat.instSuccAddOrder._proof_1 | Mathlib.Order.SuccPred.PNat | ∀ (x : ℕ+), SuccOrder.succ x = SuccOrder.succ x | null | false |
_private.Mathlib.Analysis.MellinInversion.0.rexp_cexp_aux._simp_1_1 | Mathlib.Analysis.MellinInversion | (0 < Real.pi) = True | null | false |
_private.Lean.Elab.PreDefinition.PartialFixpoint.Induction.0.Lean.Elab.PartialFixpoint.isPartialCorrectnessName.match_1 | Lean.Elab.PreDefinition.PartialFixpoint.Induction | (motive : String → Sort u_1) →
(s : String) →
(Unit → motive "partial_correctness") →
(Unit → motive "mutual_partial_correctness") → ((x : String) → motive x) → motive s | null | false |
Std.DTreeMap.Raw.isEmpty_emptyc | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}, ∅.isEmpty = true | null | true |
ArithmeticFunction.instSemiring._proof_2 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : Semiring R] (f : ArithmeticFunction R), f * 0 = 0 | null | false |
Lean.Elab.Term.Do.Code.continue.inj | Lean.Elab.Do.Legacy | ∀ {ref ref_1 : Lean.Syntax}, Lean.Elab.Term.Do.Code.continue ref = Lean.Elab.Term.Do.Code.continue ref_1 → ref = ref_1 | null | true |
contMDiffWithinAt_one | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : 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] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSp... | null | true |
AffineSubspace.dim_lt_aleph0._simp_1 | Mathlib.LinearAlgebra.AffineSpace.Dimension | ∀ {R : Type u} {V : Type v} {A : Type a} [inst : AddCommGroup V] [inst_1 : AddTorsor V A] [inst_2 : Ring R]
[inst_3 : Module R V] [StrongRankCondition R] (s : AffineSubspace R A) [Module.Finite R ↥s.direction],
(s.dim < ↑Cardinal.aleph0) = True | null | false |
Algebra.PreSubmersivePresentation.algebra._inherited_default | Mathlib.RingTheory.Extension.Presentation.Submersive | {R : Type u} →
{S : Type v} →
{ι : Type w} →
{σ : Type t} →
{inst : CommRing R} → {inst_1 : CommRing S} → {inst_2 : Algebra R S} → (ι → S) → Algebra (MvPolynomial ι R) S | null | false |
Lean.Elab.Tactic.setGrindParams | Lean.Elab.Tactic.Grind.Main | Lean.TSyntax `tactic → Array Lean.Syntax → Lean.TSyntax `tactic | null | true |
Mathlib.Tactic.FieldSimp.Sign.ctorElimType | Mathlib.Tactic.FieldSimp.Lemmas | {v : Lean.Level} → {M : Q(Type v)} → {motive : Mathlib.Tactic.FieldSimp.Sign M → Sort u} → ℕ → Sort (max 1 u) | null | false |
Lean.Language.SnapshotTask.ReportingRange.ctorIdx | Lean.Language.Basic | Lean.Language.SnapshotTask.ReportingRange → ℕ | null | false |
withBotSucc_one | Mathlib.Order.SuccPred.Nat | WithBot.succ 1 = 2 | null | true |
Matroid.eq_freeOn_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M : Matroid α} {E : Set α}, M = Matroid.freeOn E ↔ M.E = E ∧ M.Indep E | null | true |
_private.Mathlib.Topology.ClusterPt.0.accPt_iff_frequently._simp_1_2 | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X},
ClusterPt x (Filter.principal s) = ∃ᶠ (y : X) in nhds x, y ∈ s | null | false |
StarAlgEquiv.aut._proof_5 | Mathlib.Algebra.Star.StarAlgHom | ∀ {S : Type u_1} {R : Type u_2} [inst : Mul R] [inst_1 : Add R] [inst_2 : Star R] [inst_3 : SMul S R] (n : ℕ)
(a : R ≃⋆ₐ[S] R), a ^ ↑n.succ = a ^ ↑n * a | null | false |
ApproximatesLinearOn.toOpenPartialHomeomorph_coe | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E → F)
{f' : E ≃L[𝕜] F} (s : Set E) {c : NNReal} [inst_5 : CompleteSpace E] (hf : ApproximatesLinearOn f (... | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.instOrderBot._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (U : ↑X.affineOpens) (f : ↑(X.presheaf.obj (Opposite.op ↑U))),
Ideal.map (CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op)) (⊥ U) = ⊥ (X.affineBasicOpen f) | null | false |
Lean.Grind.GrobnerConfig.noConfusionType | Init.Grind.Config | Sort u → Lean.Grind.GrobnerConfig → Lean.Grind.GrobnerConfig → Sort u | null | false |
AddOpposite.instGroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [Group α] → Group αᵃᵒᵖ | null | true |
Lean.Core.SavedState._sizeOf_1 | Lean.CoreM | Lean.Core.SavedState → ℕ | null | false |
_private.Mathlib.Geometry.Euclidean.Similarity.0.Similar.angle_eq._proof_1_3 | Mathlib.Geometry.Euclidean.Similarity | ∀ {P₁ : Type u_1} {P₂ : Type u_2} [inst : MetricSpace P₁] [inst_1 : MetricSpace P₂] {b c : P₁} {b' c' : P₂} (r : ℝ),
dist c b = r * dist c' b' → dist c' b' = 0 → dist c b = 0 | null | false |
RingCat.Colimits.descMorphism._proof_1 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat)
(s : CategoryTheory.Limits.Cocone F) (x y : RingCat.Colimits.ColimitType F),
RingCat.Colimits.descFun F s (x * y) = RingCat.Colimits.descFun F s x * RingCat.Colimits.descFun F s y | null | false |
AlgebraicGeometry.LocallyRingedSpace.coproductCofanIsColimit | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.HasColimits | {ι : Type v} →
[inst : Small.{u, v} ι] →
(F : CategoryTheory.Functor (CategoryTheory.Discrete ι) AlgebraicGeometry.LocallyRingedSpace) →
CategoryTheory.Limits.IsColimit (AlgebraicGeometry.LocallyRingedSpace.coproductCofan F) | The explicit coproduct cofan constructed in `coproductCofan` is indeed a colimit. | true |
Submodule.reflection_trans_reflection | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection],
K.reflection.trans K.reflection = LinearIsometryEquiv.refl 𝕜 E | Reflection is involutive. | true |
CategoryTheory.MonoidalCategory.leftUnitor_tensor_hom''_assoc | Mathlib.CategoryTheory.Monoidal.CoherenceLemmas | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
{Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (CategoryTheory.MonoidalCategoryStru... | null | true |
leftAddCoset_eq_iff | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] (s : AddSubgroup α) {x y : α}, x +ᵥ ↑s = y +ᵥ ↑s ↔ -x + y ∈ s | null | true |
Std.DTreeMap.Raw.Const.get!_filter' | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited β] {f : α → β → Bool} {k : α},
t.WF →
Std.DTreeMap.Raw.Const.get! (Std.DTreeMap.Raw.filter f t) k =
(Option.filter (f k) (Std.DTreeMap.Raw.Const.get? t ... | Simpler variant of `get!_filter` when `LawfulEqCmp` is available. | true |
AdjoinRoot.instCommRing._proof_1 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower ℕ R R | null | false |
EuclideanGeometry.preimage_inversion_sphere_dist_center | Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c y : P} {R : ℝ},
R ≠ 0 →
y ≠ c →
EuclideanGeometry.inversion c R ⁻¹' Metric.sphere y (dist y c) =
insert c ↑(AffineSubspace.perpBisector c (Eucli... | null | true |
LinearOrderedCommGroup.zpowersOrderMonoidIso._simp_9 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
NonUnitalSubalgebra.center_eq_top | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ (R : Type u_1) [inst : CommSemiring R] (A : Type u_3) [inst_1 : NonUnitalCommSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A], NonUnitalSubalgebra.center R A = ⊤ | null | true |
CategoryTheory.Bicategory.whiskerRight_congr._proof_1 | Mathlib.CategoryTheory.Bicategory.EqToHom | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {y z : B} {g g' : y ⟶ z},
g = g' → ∀ {x : B} {f : x ⟶ y}, CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f g' | null | false |
Std.Tactic.BVDecide.BVBinOp.ctorIdx | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVBinOp → ℕ | null | false |
Matroid.Finite.ground_finite | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} [self : M.Finite], M.E.Finite | The ground set is finite | true |
SSet.Subcomplex.PairingCore.type₁_dim | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} (h : A.PairingCore) (s : h.ι), (h.type₁ s).dim = h.dim s + 1 | null | true |
Part.map_map | Mathlib.Data.Part | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β) (o : Part α),
Part.map g (Part.map f o) = Part.map (g ∘ f) o | null | true |
FractionalIdeal.coeToSubmodule | 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] → FractionalIdeal S P → Submodule R P | Map a fractional ideal `I` to a submodule by forgetting that `∃ a, a I ⊆ R`.
This implements the coercion `FractionalIdeal S P → Submodule R P`.
| true |
_private.Mathlib.Analysis.InnerProductSpace.Subspace.0.«_aux_Mathlib_Analysis_InnerProductSpace_Subspace___macroRules__private_Mathlib_Analysis_InnerProductSpace_Subspace_0_term⟪_,_⟫_1» | Mathlib.Analysis.InnerProductSpace.Subspace | Lean.Macro | null | false |
Dense.inter_of_isOpen_left | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, Dense s → Dense t → IsOpen s → Dense (s ∩ t) | The intersection of an open dense set with a dense set is a dense set. | true |
AlgebraicGeometry.Scheme.isoSpec_inv_preimage_zeroLocus | Mathlib.AlgebraicGeometry.AffineScheme | ∀ (X : AlgebraicGeometry.Scheme) [inst : AlgebraicGeometry.IsAffine X] (s : Set ↑(X.presheaf.obj (Opposite.op ⊤))),
⇑X.isoSpec.inv ⁻¹' X.zeroLocus s = PrimeSpectrum.zeroLocus s | null | true |
Mathlib.Meta.NormNum.isRat_ratCast | Mathlib.Tactic.NormNum.Inv | ∀ {R : Type u_1} [inst : DivisionRing R] [CharZero R] {q : ℚ} {n : ℤ} {d : ℕ},
Mathlib.Meta.NormNum.IsRat q n d → Mathlib.Meta.NormNum.IsRat (↑q) n d | null | true |
Std.IterM.step_eq | Init.Data.Iterators.Basic | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1}
{IsPlausibleStep : Std.IterM m β → Std.IterStep (Std.IterM m β) β → Prop}
{step : (it : Std.IterM m β) → m (Std.Shrink (Std.PlausibleIterStep (IsPlausibleStep it)))} {it : Std.IterM m β},
it.step = step it | null | true |
Equiv.commSemigroup | Mathlib.Algebra.Group.TransferInstance | {α : Type u_2} → {β : Type u_3} → α ≃ β → [CommSemigroup β] → CommSemigroup α | Transfer `CommSemigroup` across an `Equiv` | true |
WeierstrassCurve.Jacobian.polynomialZ.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Jacobian R),
W'.polynomialZ = (MvPolynomial.pderiv 2) W'.polynomial | null | true |
Submodule.map₂_bot_right | Mathlib.Algebra.Module.Submodule.Bilinear | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f : M →ₗ[R] N →ₗ[R] P) (p : Submodule R M), Submodule.map₂ f p ⊥ = ⊥ | null | true |
npowRec | Init.Data.Zero | {M : Type u_1} → [One M] → [Mul M] → ℕ → M → M | The fundamental power operation in a monoid.
`npowRec n a = a*a*...*a` n times.
This function should not be used directly; it is often used to implement a `Pow M Nat` instance,
but end users should use the `a ^ n` notation instead.
| true |
nhdsWithin_Iio_isMeasurablyGenerated | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] {mα : MeasurableSpace α} [OpensMeasurableSpace α] [inst_2 : LinearOrder α]
{a b : α} [ClosedIciTopology α], (nhdsWithin a (Set.Iio b)).IsMeasurablyGenerated | null | true |
IsDedekindDomain.HeightOneSpectrum.valuation_of_mk' | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) {r : R}
{s : ↥(nonZeroDivisors R)},
(IsDedekindDomain.HeightOneSpectrum.valuation K v) (IsLocalization.mk' K r s) = v... | The `v`-adic valuation of `r / s : K` is the valuation of `r` divided by the valuation of `s`. | true |
Lean.Core.getAndEmptyMessageLog | Lean.CoreM | Lean.CoreM Lean.MessageLog | Returns the current log and then resets its messages while adjusting `MessageLog.hadErrors`. Used
for incremental reporting during elaboration of a single command.
| true |
SubAddAction.ofStabilizer | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | (G : Type u_1) →
[inst : AddGroup G] →
{α : Type u_2} → [inst_1 : AddAction G α] → (a : α) → SubAddAction (↥(AddAction.stabilizer G a)) α | Action of the stabilizer of a point on the complement. | true |
Std.DTreeMap.Internal.Impl.Const.get_insert! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
(h : t.WF) {k a : α} {v : β}
{h₁ : Std.DTreeMap.Internal.Impl.contains a (Std.DTreeMap.Internal.Impl.insert! k v t) = true},
Std.DTreeMap.Internal.Impl.Const.get (Std.DTreeMap.Internal.Impl.insert! ... | null | true |
Std.TreeMap.Raw.mem_toArray_iff_getElem?_eq_some._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t.WF → ∀ {k : α} {v : β}, ((k, v) ∈ t.toArray) = (t[k]? = some v) | null | false |
PadicInt.continuous_choose | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (k : ℕ), Continuous fun x => Ring.choose x k | null | true |
HahnSeries.instNontrivialOfNonempty | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [Nonempty Γ] [Nontrivial R],
Nontrivial (HahnSeries Γ R) | null | true |
ContinuousMap.instNormedRing._proof_4 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] {R : Type u_2} [inst_2 : NormedRing R]
(a b c : C(α, R)), a * (b + c) = a * b + a * c | null | false |
_private.Mathlib.Logic.Equiv.Prod.0.Equiv.prodCongrLeft._proof_3 | Mathlib.Logic.Equiv.Prod | ∀ {α₁ : Type u_2} {β₁ : Type u_1} {β₂ : Type u_3} (e : α₁ → β₁ ≃ β₂),
Function.RightInverse (fun ab => ((e ab.2).symm ab.1, ab.2)) fun ab => ((e ab.2) ab.1, ab.2) | null | false |
SimplexCategory.Truncated.δ₂._auto_1 | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | Lean.Syntax | null | false |
Fin.pos | Init.Data.Fin.Basic | ∀ {n : ℕ} (i : Fin n), 0 < n | If you actually have an element of `Fin n`, then the `n` is always positive | true |
Std.Http.Internal.Mock.Client.tryRecv? | Std.Http.Transport | Std.Http.Internal.Mock.Client → optParam UInt64 0 → BaseIO (Option ByteArray) | Tries to receive data without blocking, joining all immediately available chunks.
Returns `none` if no data is available.
| true |
Module.IsReflexive.of_finite_of_free | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[Module.Finite R M] [Module.Free R M], Module.IsReflexive R M | See also `Module.instFiniteDimensionalOfIsReflexive` for the converse over a field. | true |
CategoryTheory.FilteredObject.Hom.recOn | Mathlib.CategoryTheory.Filtration.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type u_1} →
[inst_1 : CategoryTheory.Category.{u_2, u_1} I] →
{F G : CategoryTheory.FilteredObject C I} →
{motive : F.Hom G → Sort u_3} →
(t : F.Hom G) →
((hom : F.X ⟶ G.X) →
(natTra... | null | false |
Algebra.Extension.tensorCotangentSpaceOfFormallyEtale._proof_22 | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u_4} {S : Type u_1} {T : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [IsScalarTower R S T] {P : Algebra.Extension R S}
{Q : Algebra.Extension R T} (f : P.Hom Q) (H : f.toRingHom.FormallyEtale) (x : TensorP... | null | false |
Std.Time.Text.noConfusion | Std.Time.Format.Modifier | {P : Sort v✝} → {x y : Std.Time.Text} → x = y → Std.Time.Text.noConfusionType P x y | null | false |
ProfiniteAddGrp.ProfiniteCompletion.finiteAddGrpDiagram._proof_4 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ (G : AddGrpCat) (H : FiniteIndexNormalAddSubgroup ↑G), Finite (↑G ⧸ H.toAddSubgroup) | null | false |
_private.Lean.Meta.Tactic.AuxLemma.0.Lean.Meta.initFn._@.Lean.Meta.Tactic.AuxLemma.830486828._hygCtx._hyg.2 | Lean.Meta.Tactic.AuxLemma | IO (Lean.EnvExtension Lean.Meta.AuxLemmas) | null | false |
Lean.Elab.Term.ElabElim.setMotive | Lean.Elab.App | Lean.Expr → Lean.Elab.Term.ElabElim.M Unit | Set the `motive` field in the state. | true |
Manifold.IsImmersionAt.writtenInCharts | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {E'' : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] {H : Type u_7}
[inst_5 : TopologicalSpace H] {G : Type u_9} [inst_6 : TopologicalSpace G] {I : ModelWithCorn... | null | true |
Nat.sub_one_eq_self | Init.Data.Nat.Basic | ∀ {n : ℕ}, n - 1 = n ↔ n = 0 | null | true |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.isApproximateSubgroup_one._simp_1_3 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {α : Type u_1} {s : Finset α} {a : α}, (s ⊆ {a}) = (s = ∅ ∨ s = {a}) | null | false |
northcott_iff | Mathlib.Order.Northcott | ∀ {α : Type u_1} {β : Type u_2} (h : α → β) [inst : LE β], Northcott h ↔ ∀ (b : β), {a | h a ≤ b}.Finite | null | true |
Std.DTreeMap.Internal.Impl.Const.alter._proof_16 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : Type u_2} (k : α) (v : β),
(Std.DTreeMap.Internal.Impl.inner 1 k v Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf).size ≤
Std.DTreeMap.Internal.Impl.leaf.size + 1 | null | false |
Std.Internal.List.getKey | Std.Data.Internal.List.Associative | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] → (a : α) → (l : List ((a : α) × β a)) → Std.Internal.List.containsKey a l = true → α | Internal implementation detail of the hash map | true |
Set.Icc_subset_Icc_left | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b : α}, a₁ ≤ a₂ → Set.Icc a₂ b ⊆ Set.Icc a₁ b | null | true |
CategoryTheory.Limits.BinaryCofan | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | {C : Type u} → [CategoryTheory.Category.{v, u} C] → C → C → Type (max (max 0 u) v) | A binary cofan is just a cocone on a diagram indexing a coproduct. | true |
Nucleus.map_himp_apply | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (n : Nucleus X) (x y : X), n (x ⇨ n y) = x ⇨ n y | null | true |
MeasureTheory.condExp_mul_of_stronglyMeasurable_right | Mathlib.MeasureTheory.Function.ConditionalExpectation.PullOut | ∀ {Ω : Type u_1} {m mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {f g : Ω → ℝ},
MeasureTheory.StronglyMeasurable g →
MeasureTheory.Integrable (f * g) μ → MeasureTheory.Integrable f μ → μ[f * g | m] =ᵐ[μ] μ[f | m] * g | Pull-out property of the conditional expectation. | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.isValidSearchFrom_toList._proof_1_12 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {stackPos needlePos : String.Pos.Raw},
needlePos.byteIdx ≤ stackPos.byteIdx → ¬needlePos.byteIdx = 0 → ¬needlePos.byteIdx - 1 < stackPos.byteIdx → False | null | false |
Lean.Parser.Tactic.decide | Init.Tactics | Lean.ParserDescr | `decide` attempts to prove the main goal (with target type `p`) by synthesizing an instance of `Decidable p`
and then reducing that instance to evaluate the truth value of `p`.
If it reduces to `isTrue h`, then `h` is a proof of `p` that closes the goal.
The target is not allowed to contain local variables or metavari... | true |
Matrix.UnitaryGroup.toLinearEquiv._proof_7 | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type u_2} [inst_2 : CommRing α] [inst_3 : StarRing α]
(A : ↥(Matrix.unitaryGroup n α)) (x : n → α), (Matrix.UnitaryGroup.toLin' A ∘ₗ Matrix.UnitaryGroup.toLin' A⁻¹) x = x | null | false |
BialgHom.coe_toAlgHom | Mathlib.RingTheory.Bialgebra.Hom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
(f : A →ₐc[R] B), ⇑↑f = ⇑f | null | true |
Std.DTreeMap.Raw.minKey!_insert | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α],
t.WF →
∀ {k : α} {v : β k}, (t.insert k v).minKey! = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k' | null | true |
BialgHom.toAlgHom._proof_1 | Mathlib.RingTheory.Bialgebra.Hom | ∀ {R : Type u_3} {A : Type u_2} {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] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
(f : A →ₐc[R] B) (r : R), f.toFun ((algebraMap R A) r) = (algebraMap R B) r | null | false |
Std.TreeSet.Raw.min?_eq_some_min! | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → t.isEmpty = false → t.min? = some t.min! | null | true |
ProbabilityTheory.iIndepFun.hasGaussianLaw_fun_add | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Independence | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E] [SecondCountableTopology E] [CompleteSpace E]
{X Y : Ω → E},
ProbabilityTheory.HasGaussianLaw X P →
ProbabilityTheory.HasG... | null | true |
Std.Sat.AIG.denote_idx_trichotomy | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {start : ℕ} {assign : α → Bool} {invert res : Bool}
{aig : Std.Sat.AIG α} {hstart : start < aig.decls.size},
(aig.decls[start] = Std.Sat.AIG.Decl.false →
⟦assign, { aig := aig, ref := { gate := start, invert := invert, hgate := hstart } }⟧ = res) →
... | null | true |
PreQuasiregular.instMonoid._proof_1 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] (x y z : PreQuasiregular R), x * y * z = x * (y * z) | null | false |
OreLocalization.mul_cancel | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {r : R} {s t : ↥S},
↑s /ₒ t * (r /ₒ s) = r /ₒ t | null | true |
ProbabilityTheory.Kernel.fst_prod | Mathlib.Probability.Kernel.Composition.Prod | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ]
(η : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsMarkovKernel η], (κ.prod η).fst = κ | null | true |
Std.ExtHashMap.getKey_union_of_not_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 : α} (not_mem : k ∉ m₂) {h' : k ∈ m₁ ∪ m₂}, (m₁ ∪ m₂).getKey k h' = m₁.getKey k ⋯ | null | true |
CategoryTheory.Iso.op._proof_2 | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (α : X ≅ Y),
CategoryTheory.CategoryStruct.comp α.inv.op α.hom.op = CategoryTheory.CategoryStruct.id (Opposite.op X) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.