name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Units.opEquiv._proof_9 | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : Monoid M] (x x_1 : Mᵐᵒᵖˣ),
MulOpposite.op
{ val := MulOpposite.unop ↑(x * x_1), inv := MulOpposite.unop ↑(x * x_1)⁻¹, val_inv := ⋯, inv_val := ⋯ } =
MulOpposite.op { val := MulOpposite.unop ↑x, inv := MulOpposite.unop ↑x⁻¹, val_inv := ⋯, inv_val := ⋯ } *
MulOpposite.op { val :... | null | false |
_private.Mathlib.Analysis.Convex.Intrinsic.0.intrinsicInterior_nonempty._simp_1_1 | Mathlib.Analysis.Convex.Intrinsic | ∀ {α : Type u} {s : Set α}, s.Nonempty = (s ≠ ∅) | null | false |
IdemSemiring.toSemilatticeSup | Mathlib.Algebra.Order.Kleene | {α : Type u_5} → [self : IdemSemiring α] → SemilatticeSup α | null | true |
_private.Mathlib.Topology.Sequences.0.IsSeqCompact.isComplete._simp_1_6 | Mathlib.Topology.Sequences | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic.0.InnerProductGeometry.sin_angle._simp_1_1 | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
CategoryTheory.Limits.MulticospanIndex.fstPiMapOfIsLimit | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Limits.MulticospanShape} →
(I : CategoryTheory.Limits.MulticospanIndex J C) →
(c : CategoryTheory.Limits.Fan I.left) →
{d : CategoryTheory.Limits.Fan I.right} → CategoryTheory.Limits.IsLimit d → (c.pt ⟶ d.pt) | The induced map `∏ᶜ I.left ⟶ ∏ᶜ I.right` via `I.fst` for limiting fans. | true |
groupHomology.d₁₀_single_inv | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) (g : G) (a : ↑A),
((CategoryTheory.ConcreteCategory.hom (groupHomology.d₁₀ A)) fun₀ | g⁻¹ => a) =
-(CategoryTheory.ConcreteCategory.hom (groupHomology.d₁₀ A)) fun₀ | g => (A.ρ g) a | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getElem_shiftLeft._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | null | false |
CategoryTheory.Limits.Bicones.functoriality._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_5} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : J → C) (G : CategoryTheory.Functor C D)
[G.PreservesZeroMorphism... | null | false |
Finsupp.embDomain_trans_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [inst : AddCommMonoid M] (v : α →₀ M) (f : α ↪ β)
(g : β ↪ γ), Finsupp.embDomain (f.trans g) v = Finsupp.embDomain g (Finsupp.embDomain f v) | null | true |
Std.DTreeMap.Raw.getKeyD_eq_of_contains | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t.WF → ∀ {k fallback : α}, t.contains k = true → t.getKeyD k fallback = k | null | true |
Finset.powersetCard_card_add | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {n : ℕ} (s : Finset α), 0 < n → Finset.powersetCard (s.card + n) s = ∅ | null | true |
HopfAlgCat.MonoidalCategory.inducingFunctorData_εIso | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u) [inst : CommRing R],
(HopfAlgCat.MonoidalCategory.inducingFunctorData R).εIso =
CategoryTheory.Iso.refl (CategoryTheory.MonoidalCategoryStruct.tensorUnit (BialgCat R)) | null | true |
CoxeterSystem.getElem_alternatingWord | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (i j : B) (p k : ℕ) (hk : k < p),
(CoxeterSystem.alternatingWord i j p)[k] = if Even (p + k) then i else j | null | true |
Std.Http.URI.instBEqOrigin.beq | Std.Http.Data.URI.Basic | Std.Http.URI.Origin → Std.Http.URI.Origin → Bool | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.0.homotopy_congruence.match_1 | Mathlib.Algebra.Homology.HomotopyCategory | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
(c : ComplexShape ι) {Y Z : HomologicalComplex V c} (x x_1 : Y ⟶ Z) (motive : homotopic V c x x_1 → Prop)
(x_2 : homotopic V c x x_1), (∀ (i : Homotopy x x_1), motive ⋯) → motive x_2 | null | false |
_private.Lean.Compiler.LCNF.ToImpureType.0.Lean.Compiler.LCNF.computeImpureType.match_1 | Lean.Compiler.LCNF.ToImpureType | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((type : Lean.Expr) → motive (some type)) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
AffineEquiv.constVAdd_apply | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ (k : Type u_1) (P₁ : Type u_2) {V₁ : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (v : V₁) (x : P₁), (AffineEquiv.constVAdd k P₁ v) x = v +ᵥ x | null | true |
Besicovitch.TauPackage.color_lt | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
{i : Ordinal.{u}}, i < p.lastStep → ∀ {N : ℕ}, IsEmpty (Besicovitch.SatelliteConfig α N p.τ) → p.color i < N | If there are no configurations of satellites with `N+1` points, one never uses more than `N`
distinct families in the Besicovitch inductive construction. | true |
Batteries.CodeAction.TacticCodeActionEntry._sizeOf_inst | Batteries.CodeAction.Attr | SizeOf Batteries.CodeAction.TacticCodeActionEntry | null | false |
Monoid.PushoutI.NormalWord.Transversal.noConfusionType | Mathlib.GroupTheory.PushoutI | Sort u →
{ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
[inst : (i : ι) → Group (G i)] →
[inst_1 : Group H] →
{φ : (i : ι) → H →* G i} →
Monoid.PushoutI.NormalWord.Transversal φ →
{ι' : Type u_1} →
{G' : ι' → Type u_2} →
... | null | false |
instRingFreeRing._proof_6 | Mathlib.RingTheory.FreeRing | ∀ (α : Type u_1) (a : FreeRing α), 0 + a = a | null | false |
Lean.Grind.Order.le_eq_false_k | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] [inst_3 : Std.IsPreorder α]
[inst_4 : Lean.Grind.Ring α] [Lean.Grind.OrderedRing α] {a : α} {k : ℤ}, k.blt' 0 = true → (a ≤ a + ↑k) = False | null | true |
Int64.instLawfulEqOrd | Init.Data.Ord.SInt | Std.LawfulEqOrd Int64 | null | true |
Lean.Meta.InjectionsResult.ctorIdx | Lean.Meta.Tactic.Injection | Lean.Meta.InjectionsResult → ℕ | null | false |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.toNat_toInt_add_one_sub_toInt._proof_1_6 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (lo hi : BitVec (n + 1)),
¬(↑(hi.toNat + (BitVec.Signed.intMinSealed✝ (n + 1)).toNat) % ↑(2 ^ (n + 1)) + 1 -
↑(lo.toNat + (BitVec.Signed.intMinSealed✝ (n + 1)).toNat) % ↑(2 ^ (n + 1))).toNat =
(hi.toNat + (BitVec.Signed.intMinSealed✝ (n + 1)).toNat) % 2 ^ (n + 1) + 1 -
(lo.toNa... | null | false |
SSet.Subcomplex.mem_ofSimplex_obj_iff | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {X : SSet} {n : ℕ} (x : X.obj (Opposite.op { len := n })) {m : SimplexCategoryᵒᵖ} (y : X.obj m),
y ∈ (SSet.Subcomplex.ofSimplex x).obj m ↔ ∃ f, (CategoryTheory.ConcreteCategory.hom (X.map f.op)) x = y | null | true |
Batteries.Random.MersenneTwister.State._sizeOf_inst | Batteries.Data.Random.MersenneTwister | (cfg : Batteries.Random.MersenneTwister.Config) → SizeOf (Batteries.Random.MersenneTwister.State cfg) | null | false |
Quandle | Mathlib.Algebra.Quandle | Type u_1 → Type u_1 | A quandle is a rack such that each automorphism fixes its corresponding element.
| true |
Std.DTreeMap.Internal.Impl.minKey?_le_minKey?_erase! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k km kme : α} (hkme : (Std.DTreeMap.Internal.Impl.erase! k t).minKey? = some kme),
t.minKey?.get ⋯ = km → (compare km kme).isLE = true | null | true |
SelectInsertParams.mk.noConfusion | Mathlib.Tactic.Widget.SelectPanelUtils | {P : Sort u} →
{pos : Lean.Lsp.Position} →
{goals : Array Lean.Widget.InteractiveGoal} →
{selectedLocations : Array Lean.SubExpr.GoalsLocation} →
{replaceRange : Lean.Lsp.Range} →
{pos' : Lean.Lsp.Position} →
{goals' : Array Lean.Widget.InteractiveGoal} →
{selecte... | null | false |
CategoryTheory.instPreadditiveOppositeShift._proof_4 | Mathlib.CategoryTheory.Shift.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (A : Type u_3) [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] [inst_3 : CategoryTheory.Preadditive C],
autoParam
(∀ (P Q R : CategoryTheory.OppositeShift C A) (f : P ⟶ Q) (g g' : Q ⟶ R),
CategoryTheory.CategoryStruct.comp f (g +... | null | false |
Polynomial.newtonMap_apply_of_not_isUnit | Mathlib.Dynamics.Newton | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Polynomial R}
{x : S}, ¬IsUnit ((Polynomial.aeval x) (Polynomial.derivative P)) → P.newtonMap x = x | null | true |
PresheafOfModulesOfCommRing.Derivation.postcomp._proof_2 | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_3, u_1} D] {S : CategoryTheory.Functor Cᵒᵖ CommRingCat}
{F : CategoryTheory.Functor C D} {R : CategoryTheory.Functor Dᵒᵖ CommRingCat} {M N : PresheafOfModulesOfCommRing R}
{φ : S ⟶ F.op.comp R} (d : ... | null | false |
Nat.le_or_le_of_add_eq_add_pred | Init.Data.Nat.Lemmas | ∀ {a c b d : ℕ}, a + c = b + d - 1 → b ≤ a ∨ d ≤ c | null | true |
_private.Mathlib.MeasureTheory.Function.UnifTight.0.MeasureTheory.UnifTight.aeeq._simp_1_1 | Mathlib.MeasureTheory.Function.UnifTight | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary._proof_2 | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} (a₁ : ℤ) (x₁ : Q(«$M»)) (k₁ : ℕ) (t₁ : List ((ℤ × Q(«$M»)) × ℕ)) (a₂ : ℤ)
(x₂ : Q(«$M»)) (k₂ : ℕ) (t₂ : List ((ℤ × Q(«$M»)) × ℕ)),
(invImage (fun x => PSigma.casesOn x fun l₁ l₂ => (l₁, l₂)) Prod.instWellFoundedRelation).1 ⟨t₁, ((a₂, x₂), k₂) :: t₂⟩
⟨((a₁, x₁), k₁) :: t₁, ((a₂... | null | false |
SzemerediRegularity.bound.eq_1 | Mathlib.Combinatorics.SimpleGraph.Regularity.Lemma | ∀ (ε : ℝ) (l : ℕ),
SzemerediRegularity.bound ε l =
SzemerediRegularity.stepBound^[⌊4 / ε ^ 5⌋₊] (SzemerediRegularity.initialBound ε l) *
16 ^ SzemerediRegularity.stepBound^[⌊4 / ε ^ 5⌋₊] (SzemerediRegularity.initialBound ε l) | null | true |
CategoryTheory.eq_of_comp_left_eq' | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y),
((fun {Z} h => CategoryTheory.CategoryStruct.comp f h) = fun {Z} h => CategoryTheory.CategoryStruct.comp g h) → f = g | null | true |
Std.WP.WPMonad.of_frameClosure | Std.WP.Monad.Frame | {m : Type → Type} →
[inst : Monad m] →
{P : Type u} →
{E : Type z} →
[inst_1 : Std.WP.Assertion P] →
[inst_2 : Std.WP.Assertion E] →
{R : Type} →
(op : R → P → P) →
[∀ (r : R), Lean.Order.PreservesSup (op r)] →
{comp : R → R → R} ... | Reinterpret a `WPMonad m` so its weakest precondition is the `frameClosure` of the
base wp over a family of supremum-preserving resource operators `op r` that act by `comp` with
unit `e`.
The resource frame rule then holds by construction (`WP.Frames.of_frameClosure`).
A separation logic depends on this property: ever... | true |
_private.Mathlib.Analysis.LocallyConvex.WithSeminorms.0.WithSeminorms.isVonNBounded_iff_seminorm_bddAbove._simp_1_1 | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, BddAbove s = ∃ x, ∀ y ∈ s, y ≤ x | null | false |
Pi.uniformSpace_comap_restrict | Mathlib.Topology.UniformSpace.Pi | ∀ {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] (S : Set ι),
UniformSpace.comap S.domRestrict (Pi.uniformSpace fun i => α ↑i) = ⨅ i ∈ S, UniformSpace.comap (Function.eval i) (U i) | null | true |
Std.Time.TimeZone.TransitionSpec | Std.Time.Zoned.RecurringRule | Type | Specifies how a DST transition date is expressed.
| true |
Circle.instCommGroup._proof_21 | Mathlib.Analysis.Complex.Circle | autoParam (∀ (n : ℕ) (a : Circle), a ^ Int.negSucc n = (a ^ ↑n.succ)⁻¹) DivInvMonoid.zpow_neg'._autoParam | null | false |
CategoryTheory.MorphismProperty.HasRightCalculusOfFractions | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} → [inst : CategoryTheory.Category.{v_1, u_1} C] → CategoryTheory.MorphismProperty C → Prop | A multiplicative morphism property `W` has right calculus of fractions if
any left fraction can be turned into a right fraction and that two morphisms
that can be equalized by postcomposition with a morphism in `W` can also
be equalized by precomposition with a morphism in `W`. | true |
Finset.Pi.cons_injective | Mathlib.Data.Finset.Pi | ∀ {α : Type u_1} {δ : α → Sort v} [inst : DecidableEq α] {a : α} {b : δ a} {s : Finset α},
a ∉ s → Function.Injective (Finset.Pi.cons s a b) | null | true |
TopRep.toActionFromAction._proof_2 | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u_2} {G : Type u_3} [inst : TopologicalSpace k] [inst_1 : Ring k] [inst_2 : Monoid G] (X : TopRep k G),
CategoryTheory.CategoryStruct.comp
(TopRep.ofHom { toContinuousLinearMap := ContinuousLinearMap.id k ↑X, isIntertwining' := ⋯ })
(TopRep.ofHom { toContinuousLinearMap := ContinuousLinearMap.... | null | false |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.FriendlyOperationClass.comp | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | ∀ {basis_hd : ℝ → ℝ} {basis_tl : Tactic.ComputeAsymptotics.Basis} {γ : Type u_1} {γ' : Type u_2} {g : γ' → γ}
{op :
γ →
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl →
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl}
[h : Tactic.ComputeAs... | null | true |
_private.Init.Data.List.SplitOn.Basic.0.List.splitOnPTR.go._f | Init.Data.List.SplitOn.Basic | {α : Type u_1} →
(α → Bool) →
(a : List α) →
List.below (motive := fun a => Array α → Array (List α) → List (List α)) a →
Array α → Array (List α) → List (List α) | null | false |
Aesop.Frontend.Feature.priority | Aesop.Frontend.RuleExpr | Aesop.Frontend.Priority → Aesop.Frontend.Feature | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.killCopies_eq_left._simp_1_7 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Sort u_3} {p : Nonempty α → Prop}, (∀ (h : Nonempty α), p h) = ∀ (a : α), p ⋯ | null | false |
Function.Periodic.differentiable_qParam | Mathlib.Analysis.Complex.Periodic | ∀ {h : ℝ}, Differentiable ℂ (Function.Periodic.qParam h) | null | true |
SkewPolynomial.X_mul_monomial | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : MulSemiringAction (Multiplicative ℕ) R] (n : ℕ) (r : R),
SkewPolynomial.X * (SkewPolynomial.monomial n) r = (SkewPolynomial.monomial (n + 1)) (SkewPolynomial.φ r) | null | true |
Lean.Expr.NumApps.State.rec | Lean.Util.NumApps | {motive : Lean.Expr.NumApps.State → Sort u} →
((visited : Lean.PtrSet Lean.Expr) →
(counters : Lean.NameMap ℕ) → motive { visited := visited, counters := counters }) →
(t : Lean.Expr.NumApps.State) → motive t | null | false |
_private.Mathlib.AlgebraicGeometry.Limits.0.AlgebraicGeometry.IsAffineOpen.iSup_of_disjoint_aux | Mathlib.AlgebraicGeometry.Limits | ∀ {ι : Type u} {X : AlgebraicGeometry.Scheme} [Finite ι] {U : ι → X.Opens},
(∀ (i : ι), AlgebraicGeometry.IsAffineOpen (U i)) →
Pairwise (Function.onFun Disjoint U) → AlgebraicGeometry.IsAffineOpen (iSup U) | A version with more restrictive universes. See `IsAffineOpen.iSup_of_disjoint`. | true |
_private.Mathlib.Data.List.Intervals.0.List.Ico.inter_consecutive._simp_1_2 | Mathlib.Data.List.Intervals | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
Lean.Elab.Term.withMacroExpansion | Lean.Elab.Term.TermElabM | {n : Type → Type u_1} →
{α : Type} → [Monad n] → [MonadControlT Lean.Elab.TermElabM n] → Lean.Syntax → Lean.Syntax → n α → n α | Elaborate `x` with `stx` on the macro stack and produce macro expansion info | true |
Function.Embedding.sigmaSet._proof_1 | Mathlib.Logic.Embedding.Set | ∀ {α : Type u_1} {ι : Type u_2} {s : ι → Set α},
Pairwise (Function.onFun Disjoint s) → Function.Injective fun x => ↑x.snd | null | false |
_private.Mathlib.LinearAlgebra.Reflection.0.Module.reflection_mul_reflection_pow_apply._proof_1_2 | Mathlib.LinearAlgebra.Reflection | ∀ (m : ℕ), ↑m % 2 = 0 ∨ ↑m % 2 = 1 | null | false |
SSet.quasicategory_of_hasLiftingProperty | Mathlib.AlgebraicTopology.Quasicategory.Basic | ∀ (S : SSet) {X : SSet} (t : CategoryTheory.Limits.IsTerminal X),
(∀ {n : ℕ} {i : Fin (n + 1)},
0 < i → i < Fin.last n → CategoryTheory.HasLiftingProperty (SSet.horn n i).ι (t.from S)) →
S.Quasicategory | null | true |
IsClub.casesOn | Mathlib.SetTheory.Cardinal.Cofinality.Club | {α : Type u_1} →
[inst : LinearOrder α] →
{s : Set α} →
{motive : IsClub s → Sort u} →
(t : IsClub s) → ((dirSupClosed : DirSupClosed s) → (isCofinal : IsCofinal s) → motive ⋯) → motive t | null | false |
Configuration.ProjectivePlane.lineCount_eq | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} (L : Type u_2) [inst : Membership P L] [inst_1 : Configuration.ProjectivePlane P L] [Finite P]
[Finite L] (p : P), Configuration.lineCount L p = Configuration.ProjectivePlane.order P L + 1 | null | true |
_private.Lean.Meta.ExprLens.0.Lean.Core.viewBindersCoord.match_1 | Lean.Meta.ExprLens | (motive : ℕ → Lean.Expr → Sort u_1) →
(x : ℕ) →
(x_1 : Lean.Expr) →
((n : Lean.Name) →
(y body : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive 1 (Lean.Expr.lam n y body binderInfo)) →
((n : Lean.Name) →
(y body : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive 1 (Le... | null | false |
BoundedVariationOn.stieltjesFunctionRightLim.congr_simp | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : OrderTopology α] {E : Type u_2}
[inst_3 : NormedAddCommGroup E] [inst_4 : CompleteSpace E] {f f_1 : α → E} (e_f : f = f_1)
(hf : BoundedVariationOn f Set.univ) (x₀ x₀_1 : α),
x₀ = x₀_1 → hf.stieltjesFunctionRightLim x₀ = ⋯.stieltjesFu... | null | true |
PresheafOfModules.limitPresheafOfModules_obj | Mathlib.Algebra.Category.ModuleCat.Presheaf.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
[inst_2 :
∀ (X : Cᵒᵖ),
Small.{v, max u₂ v}
↑((F.comp (PresheafOfModules.evaluation R... | null | true |
Batteries.AssocList.all._f | Batteries.Data.AssocList.Basic | {α : Type u_1} → {β : Type u_2} → (α → β → Bool) → (x : Batteries.AssocList α β) → Batteries.AssocList.below x → Bool | null | false |
SSet.Truncated.StrictSegal.spine_δ_arrow_lt | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ} {X : SSet.Truncated (n + 1)} (sx : X.StrictSegal) (m : ℕ) (h : m ≤ n) (f : X.Path (m + 1)) {i : Fin m}
{j : Fin (m + 2)},
i.succ.castSucc < j →
(X.spine m ⋯
((CategoryTheory.ConcreteCategory.hom
(X.map (SimplexCategory.Truncated.Hom.tr (SimplexCategory.δ j) ⋯ ⋯).op))
... | If we take the path along the spine of the `j`th face of a `spineToSimplex`,
the common arrows will agree with those of the original path `f`. In particular,
an arrow `i` with `i + 1 < j` can be identified with the same arrow in `f`. | true |
Subalgebra.instCommRingSubtypeMemCenter._proof_10 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Ring A] [inst_2 : Algebra R A],
autoParam (∀ (n : ℕ) (a : ↥(Subalgebra.center R A)), Int.negSucc n • a = -(↑n.succ • a))
SubNegMonoid.zsmul_neg'._autoParam | null | false |
Aesop.UnfoldRule.mk | Aesop.Rule | Lean.Name → Option Lean.Name → Aesop.UnfoldRule | null | true |
intervalIntegral.FTCFilter.nhdsUniv | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ (a : ℝ), intervalIntegral.FTCFilter a (nhdsWithin a Set.univ) (nhds a) | null | true |
AddCircle.haarAddCircle._proof_2 | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ}, IsTopologicalAddGroup (ℝ ⧸ AddSubgroup.zmultiples T) | null | false |
Lean.Elab.Tactic.MkSimpContextResult.ctorIdx | Lean.Elab.Tactic.Simp | Lean.Elab.Tactic.MkSimpContextResult → ℕ | null | false |
CategoryTheory.Adjunction.rightAdjointLaxMonoidal | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
{G : Cate... | The right adjoint of an oplax monoidal functor is lax monoidal. | true |
Valuation.IsRankOneDiscrete.generator_ne_zero | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {A : Type u_2} [inst_1 : Ring A] (v : Valuation A Γ)
[inst_2 : v.IsRankOneDiscrete], ↑(Valuation.IsRankOneDiscrete.generator v) ≠ 0 | null | true |
CategoryTheory.MorphismProperty.RightFraction₂.mk.sizeOf_spec | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
[inst_1 : SizeOf C] [inst_2 : ⦃X Y : C⦄ → (x : X ⟶ Y) → SizeOf (W x)] {X' : C} (s : X' ⟶ X) (hs : W s)
(f f' : X' ⟶ Y),
sizeOf { X' := X', s := s, hs := hs, f := f, f' := f' } = 1 + sizeOf X' + sizeOf ... | null | true |
Equiv.sigmaEquivOptionOfInhabited.match_1 | Mathlib.Logic.Equiv.Sum | ∀ (α : Type u_1) [inst : Inhabited α] (motive : Option { a // a ≠ default } → Prop) (x : Option { a // a ≠ default }),
(∀ (_ : Unit), motive none) → (∀ (val : α) (ha : val ≠ default), motive (some ⟨val, ha⟩)) → motive x | null | false |
AlgebraicTopology.DoldKan.Compatibility.equivalence₁CounitIso_hom_app | Mathlib.AlgebraicTopology.DoldKan.Compatibility | ∀ {A : Type u_1} {A' : Type u_2} {B' : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} A'] [inst_2 : CategoryTheory.Category.{v_4, u_4} B'] {eA : A ≌ A'}
{e' : A' ≌ B'} {F : CategoryTheory.Functor A B'} (hF : eA.functor.comp e'.functor ≅ F) (X : B'),
(Algebraic... | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.le_intMin_of_msb_eq_false.match_1_1 | Init.Data.BitVec.Lemmas | ∀ (motive : (w : ℕ) → {x : BitVec w} → x.msb = false → Prop) (w : ℕ) {x : BitVec w} (hx : x.msb = false),
(∀ (x : BitVec 0) (hx : x.msb = false), motive 0 hx) →
(∀ (w' : ℕ) (x : BitVec (w' + 1)) (hx : x.msb = false), motive w'.succ hx) → motive w hx | null | false |
MvFunctor._aux_Mathlib_Data_TypeVec___unexpand_TypeVec_Arrow_1 | Mathlib.Data.TypeVec | Lean.PrettyPrinter.Unexpander | null | false |
SimplexCategory.Truncated.δ₂_zero_eq_const | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | SimplexCategory.Truncated.δ₂ 0 SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_4
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_3 =
SimplexCategory.Truncated.Hom.tr ({ len := 0 }.const { len := 0 + 1 } 1)
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_4 SimplexCategory.Truncated.δ₂_zero_comp_... | null | true |
Finset.map_add_right_Ico | Mathlib.Algebra.Order.Interval.Finset.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelAddMonoid α]
[ExistsAddOfLE α] [inst_4 : LocallyFiniteOrder α] (a b c : α),
Finset.map (addRightEmbedding c) (Finset.Ico a b) = Finset.Ico (a + c) (b + c) | null | true |
CategoryTheory.Subfunctor.ofSection_le_iff | Mathlib.CategoryTheory.Subfunctor.OfSection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : Cᵒᵖ}
(x : F.obj X) (G : CategoryTheory.Subfunctor F), CategoryTheory.Subfunctor.ofSection x ≤ G ↔ x ∈ G.obj X | null | true |
TopCat.Hom.frameHom._proof_3 | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y : TopCat} (f : X ⟶ Y) (x x_1 : TopologicalSpace.Opens ↑Y), IsOpen (⇑(TopCat.Hom.hom f) ⁻¹' ↑(x ⊓ x_1)) | null | false |
_private.Mathlib.FieldTheory.AlgebraicClosure.0.map_mem_algebraicClosure_iff._simp_1_2 | Mathlib.FieldTheory.AlgebraicClosure | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B} [Nontrivial A],
IsIntegral A x = (minpoly A x ≠ 0) | null | false |
Std.DHashMap.Const.getD_insertIfNew | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k a : α} {fallback v : β},
Std.DHashMap.Const.getD (m.insertIfNew k v) a fallback =
if (k == a) = true ∧ k ∉ m then v else Std.DHashMap.Const.getD m a fallback | null | true |
_private.Init.Data.List.Sublist.0.List.filterMap_subset._simp_1_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {l : List α} {b : β},
(b ∈ List.filterMap f l) = ∃ a ∈ l, f a = some b | null | false |
Lean.Elab.ContextInfo.runMetaM | Lean.Elab.InfoTree.Main | {α : Type} → Lean.Elab.ContextInfo → Lean.LocalContext → Lean.MetaM α → IO α | null | true |
Finset.Int.finsetGcd_nonneg | Mathlib.Algebra.GCDMonoid.Finset | ∀ {ι : Type u_1} {s : Finset ι} {f : ι → ℤ}, 0 ≤ s.gcd f | The gcd of a finset of integers is nonnegative. | true |
Primcodable.sum._proof_2 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : Primcodable α] [inst_1 : Primcodable β] (n : ℕ),
Encodable.encode
(bif n.bodd then Option.map (fun b => 2 * Encodable.encode (n, b).2 + 1) (Encodable.decode n.div2)
else Option.map (fun b => 2 * Encodable.encode (n, b).2) (Encodable.decode n.div2)) =
Encodable.e... | null | false |
Submodule.quotEquivOfEqBot_apply_mk | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
(hp : p = ⊥) (x : M), (p.quotEquivOfEqBot hp) (Submodule.Quotient.mk x) = x | null | true |
Submonoid.mrange_snd | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N],
MonoidHom.mrange (MonoidHom.snd M N) = ⊤ | null | true |
Std.DHashMap.Internal.Raw₀.insertMany_list_singleton | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] {k : α}
{v : β k}, ↑(m.insertMany [⟨k, v⟩]) = m.insert k v | null | true |
Matroid.IsBasis.isBase_of_spanning | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {X I : Set α}, M.IsBasis I X → M.Spanning X → M.IsBase I | null | true |
Float.Model.ofUSize | Init.Data.Float.Model.Float | USize → Float.Model | Converts a `USize` to a `Float.Model`, returning positive zero on zero. | true |
Prod.instCoalgebra._proof_7 | Mathlib.RingTheory.Coalgebra.Basic | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
[inst_2 : AddCommMonoid B] [inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : Coalgebra R A]
[inst_6 : Coalgebra R B],
LinearMap.rTensor (A × B) CoalgebraStruct.counit ∘ₗ CoalgebraStruct.comul = (TensorProduct.mk ... | null | false |
LocallyConstant.coe_inj._simp_1 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f g : LocallyConstant X Y}, (⇑f = ⇑g) = (f = g) | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_mul_of_nonneg._proof_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {x y z : ℤ}, x / y / z = x / (y * z) → ¬x / (y * z) = x / y / z → False | null | false |
AlgebraicGeometry.IsAffineOpen.arrowStalkMapIso._proof_8 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {x : ↥X} (U : Y.Opens) (hU : AlgebraicGeometry.IsAffineOpen U)
(V : X.Opens) (hV : AlgebraicGeometry.IsAffineOpen V) (hVU : V ≤ (TopologicalSpace.Opens.map f.base).obj U)
(hx : x ∈ V) (this : IsLocalization.AtPrime (↑(Y.presheaf.stalk ↑⟨f x, ⋯⟩)) (hU.primeIdealOf ⟨f x,... | null | false |
MonoidAlgebra.curryAddEquiv_single | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} {N : Type u_5} [inst : Semiring R] [inst_1 : Monoid M] [inst_2 : Monoid N] (m : M)
(n : N) (r : R),
MonoidAlgebra.curryAddEquiv (MonoidAlgebra.single (m, n) r) = MonoidAlgebra.single m (MonoidAlgebra.single n r) | null | true |
Lean.Lsp.CodeActionClientCapabilities.dataSupport?._default | Lean.Data.Lsp.CodeActions | Option Bool | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.