name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.DHashMap.Internal.Raw₀.getKey?_eq_some_iff | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], (↑m).WF → ∀ {k k' : α}, m.getKey? k = some k' ↔ ∃ (h : m.contains k = true), m.getKey k h = k' | null | true |
Filter.Eventually.prodMk_nhds | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {px : X → Prop} {x : X},
(∀ᶠ (x : X) in nhds x, px x) →
∀ {py : Y → Prop} {y : Y}, (∀ᶠ (y : Y) in nhds y, py y) → ∀ᶠ (p : X × Y) in nhds (x, y), px p.1 ∧ py p.2 | null | true |
HomologicalComplex.mapBifunctor.hom_ext_iff | Mathlib.Algebra.Homology.Bifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} D] {I₁ : Type u_4}
{I₂ : Type u_5} {J : Type u_6} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂}
[inst_3 : CategoryTheory.Lim... | null | true |
Vector3.eq_nil | Mathlib.Data.Vector3 | ∀ {α : Type u_1} (v : Vector3 α 0), v = [] | null | true |
CategoryTheory.Limits.CreatesFiniteLimits.noConfusion | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{F : CategoryTheory.Functor C D} →
{t : CategoryTheory.Limits.CreatesFiniteLimits F} →
{C' : Type u₁} →
{in... | null | false |
LieRinehartRing.lie_smul_eq_mul' | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {A : Type u_1} {L : Type u_2} {inst : CommRing A} {inst_1 : LieRing L} {inst_2 : Module A L}
{inst_3 : LieRingModule L A} [self : LieRinehartRing A L] (a b : A) (x : L), ⁅a • x, b⁆ = a * ⁅x, b⁆ | null | true |
StieltjesFunction.measurable_measure | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {x : MeasurableSpace α} {f : α → StieltjesFunction ℝ},
(∀ (q : ℝ), Measurable fun a => ↑(f a) q) →
(∀ (a : α), Filter.Tendsto (↑(f a)) Filter.atBot (nhds 0)) →
(∀ (a : α), Filter.Tendsto (↑(f a)) Filter.atTop (nhds 1)) → Measurable fun a => (f a).measure | A measurable function `α → StieltjesFunction ℝ` with limits 0 at -∞ and 1 at +∞ gives a
measurable function `α → Measure ℝ` by taking `StieltjesFunction.measure` at each point. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceRotateRight._regBuiltin.BitVec.reduceRotateRight.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.3861451550._hygCtx._hyg.18 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
_private.Batteries.Tactic.Trans.0.Batteries.Tactic.initFn.match_7._@.Batteries.Tactic.Trans.2247956323._hygCtx._hyg.2 | Batteries.Tactic.Trans | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(__discr : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((xs : Array Lean.Expr) → (fst : Array Lean.BinderInfo) → (targetTy : Lean.Expr) → motive (xs, fst, targetTy)) →
motive __discr | null | false |
_private.Mathlib.MeasureTheory.Group.Integral.0.MeasureTheory.integral_eq_zero_of_mul_right_eq_neg._simp_1_2 | Mathlib.MeasureTheory.Group.Integral | ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (f : α → G), -∫ (a : α), f a ∂μ = ∫ (a : α), -f a ∂μ | null | false |
AlgebraicGeometry.Scheme.Cover.gluedCover_V | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x : 𝒰.I₀ × 𝒰.I₀),
(AlgebraicGeometry.Scheme.Cover.gluedCover 𝒰).V x =
match x with
| (x, y) => CategoryTheory.Limits.pullback (𝒰.f x) (𝒰.f y) | null | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremKind.simp.elim | Lean.Elab.Tactic.Do.Internal.VCGen.SpecDB | {motive : Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremKind → Sort u} →
(t : Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremKind) →
t.ctorIdx = 1 → ((etaArgs : ℕ) → motive (Lean.Elab.Tactic.Do.SpecAttr.SpecTheoremKind.simp etaArgs)) → motive t | null | false |
mem_leftCoset_leftCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Monoid α] (s : Submonoid α) {a : α}, a • ↑s = ↑s → a ∈ s | null | true |
Std.ExtDTreeMap.contains_alter | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k k' : α} {f : Option (β k) → Option (β k)},
(t.alter k f).contains k' = if cmp k k' = Ordering.eq then (f (t.get? k)).isSome else t.contains k' | null | true |
Real.geom_mean_le_arith_mean4_weighted | Mathlib.Analysis.MeanInequalities | ∀ {w₁ w₂ w₃ w₄ p₁ p₂ p₃ p₄ : ℝ},
0 ≤ w₁ →
0 ≤ w₂ →
0 ≤ w₃ →
0 ≤ w₄ →
0 ≤ p₁ →
0 ≤ p₂ →
0 ≤ p₃ →
0 ≤ p₄ →
w₁ + w₂ + w₃ + w₄ = 1 → p₁ ^ w₁ * p₂ ^ w₂ * p₃ ^ w₃ * p₄ ^ w₄ ≤ w₁ * p₁ + w₂ * p₂ + w₃ * p₃ + w₄ * p₄ | null | true |
addSubgroupOfIdempotent._proof_3 | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : Finite G] (S : Set G) (hS1 : S.Nonempty) (hS2 : S + S = S),
0 ∈ (addSubmonoidOfIdempotent S hS1 hS2).carrier | null | false |
IsPrimitiveRoot.disjoint | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] {k l : ℕ},
k ≠ l → Disjoint (primitiveRoots k R) (primitiveRoots l R) | The sets `primitiveRoots k R` are pairwise disjoint. | true |
Subring.comap_iInf | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {ι : Sort u_1} (f : R →+* S)
(s : ι → Subring S), Subring.comap f (iInf s) = ⨅ i, Subring.comap f (s i) | null | true |
groupCohomology.instEpiModuleCatH2π | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G),
CategoryTheory.Epi (groupCohomology.H2π A) | null | true |
CategoryTheory.StrictlyUnitaryPseudofunctorCore.map₂_whisker_right._autoParam | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | Lean.Syntax | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_ofArray._proof_1_25 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (acc : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment) (i : Std.Tactic.BVDecide.LRAT.Internal.PosFin n),
acc.size = n → ↑i < acc.size | null | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateContImp.match_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Code pu → Sort u_1) →
(c : Lean.Compiler.LCNF.Code pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) →
(k : Lean.Compiler.LCNF.Code pu) → motive (Lean.Compiler.LCNF.Code.let decl k)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) →
... | null | false |
ContDiffMapSupportedIn.bounded_iteratedFDeriv | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K) {i : ℕ},
↑i ≤ n → ∃ C, ∀ (x : E), ‖iteratedFDeriv ℝ i (⇑f) x‖ ≤ C | null | true |
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent.noConfusion | Lean.Meta.Tactic.Grind.AC.Types | {P : Sort u} →
{x : Lean.Grind.AC.Var} →
{c₁ : Lean.Meta.Grind.AC.EqCnstr} →
{x' : Lean.Grind.AC.Var} →
{c₁' : Lean.Meta.Grind.AC.EqCnstr} →
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x c₁ =
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x' c₁' →
... | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_572 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
selfZPow_mul_neg | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (x : R) (B : Type u_2) [inst_1 : CommSemiring B] [inst_2 : Algebra R B]
[inst_3 : IsLocalization.Away x B] (d : ℤ), selfZPow x B d * selfZPow x B (-d) = 1 | null | true |
CochainComplex.mappingConeCompTriangle_mor₁ | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ X₃ : CochainComplex C ℤ} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃),
(CochainComplex.mappingConeCompTriangle f g).mor₁ =
CochainComplex.mappingCone.map f (CategoryT... | null | true |
CategoryTheory.Limits.CoproductDisjoint.isPullback_of_isInitial | Mathlib.CategoryTheory.Limits.Shapes.DisjointCoproduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_1} {X : ι → C}
[CategoryTheory.Limits.CoproductDisjoint X] {c : CategoryTheory.Limits.Cofan X}
(hc : CategoryTheory.Limits.IsColimit c) {Y : C} (hY : CategoryTheory.Limits.IsInitial Y) {i j : ι}
[CategoryTheory.Limits.HasPullback (c.inj i) (c.in... | null | true |
AlgEquiv.ofInjectiveField._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_3} [inst : CommSemiring R] {E : Type u_1} {F : Type u_2} [inst_1 : DivisionRing E] [inst_2 : Semiring F]
[Nontrivial F] [inst_4 : Algebra R E] [inst_5 : Algebra R F] (f : E →ₐ[R] F), Function.Injective ⇑f.toRingHom | null | false |
Cardinal.lift_le_beth_natCast | Mathlib.SetTheory.Cardinal.Aleph | ∀ {c : Cardinal.{u}} {n : ℕ}, Cardinal.lift.{v, u} c ≤ Cardinal.beth ↑n ↔ c ≤ Cardinal.beth ↑n | null | true |
_private.Mathlib.Order.Filter.AtTopBot.CountablyGenerated.0.Filter.tendsto_iff_seq_tendsto._simp_1_2 | Mathlib.Order.Filter.AtTopBot.CountablyGenerated | ∀ {α : Type u} {f : Filter α} {s : Set α}, (f ⊓ Filter.principal s = ⊥) = (sᶜ ∈ f) | null | false |
Lean.Meta.Sym.AlphaShareCommon.State.noConfusionType | Lean.Meta.Sym.AlphaShareCommon | Sort u → Lean.Meta.Sym.AlphaShareCommon.State → Lean.Meta.Sym.AlphaShareCommon.State → Sort u | null | false |
Sum.map_bijective | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {f : α → γ} {g : β → δ},
Function.Bijective (Sum.map f g) ↔ Function.Bijective f ∧ Function.Bijective g | null | true |
Std.TreeMap.toArray_map | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} {f : α → β → γ},
(Std.TreeMap.map f t).toArray = Array.map (fun p => (p.1, f p.1 p.2)) t.toArray | null | true |
groupCohomology.linearYonedaObjResProjectiveResolutionIso._proof_9 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Shapiro | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}
(P : CategoryTheory.ProjectiveResolution (Rep.trivial k G k)) (A : Rep.{u_1, u_1, u_1} k ↥S) (x x_1 : ℕ),
(ComplexShape.up ℕ).Rel x x_1 →
CategoryTheory.CategoryStruct.comp
(Rep.resCoindHomEquiv.{u_1, u_1, u_1, u_1} S.subtype (P.... | null | false |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.RCasesPatt.tuple₁._sparseCasesOn_1 | Lean.Elab.Tactic.RCases | {motive_1 : Lean.Elab.Tactic.RCases.RCasesPatt → Sort u} →
(t : Lean.Elab.Tactic.RCases.RCasesPatt) →
((ref : Lean.Syntax) → (a : Lean.Name) → motive_1 (Lean.Elab.Tactic.RCases.RCasesPatt.one ref a)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
_private.Batteries.Tactic.Lint.Misc.0.Batteries.Tactic.Lint.docBlame._sparseCasesOn_7 | Batteries.Tactic.Lint.Misc | {α : Type u} →
{motive : Option α → Sort u_1} → (t : Option α) → motive none → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
SubAddAction.ofStabilizer.conjMap._proof_5 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_1} [inst : AddGroup G] {α : Type u_2} [inst_1 : AddAction G α] {g : G} {a b : α} (hg : b = g +ᵥ a)
(x : ↥(AddAction.stabilizer G a)) (x_1 : ↥(SubAddAction.ofStabilizer G a)),
⟨g +ᵥ ↑(x +ᵥ x_1), ⋯⟩ = (AddAction.stabilizerEquivStabilizer hg) x +ᵥ ⟨g +ᵥ ↑x_1, ⋯⟩ | null | false |
Set.chainHeight_eq_top_iff | Mathlib.Order.Height | ∀ {α : Type u_1} (s : Set α) (r : α → α → Prop), s.chainHeight r = ⊤ ↔ ∀ (n : ℕ), ∃ t ⊆ s, t.encard = ↑n ∧ IsChain r t | null | true |
_private.Init.Data.UInt.Bitwise.0.UInt8.xor_eq_zero_iff._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt8}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Lean.Elab.CompletionInfo.option.inj | Lean.Elab.InfoTree.Types | ∀ {stx stx_1 : Lean.Syntax}, Lean.Elab.CompletionInfo.option stx = Lean.Elab.CompletionInfo.option stx_1 → stx = stx_1 | null | true |
Array.toListLitAux.eq_2 | Init.Data.Array.GetLit | ∀ {α : Type u_1} (xs : Array α) (n : ℕ) (hsz : xs.size = n) (x : List α) (i : ℕ) (hi : i + 1 ≤ xs.size),
xs.toListLitAux n hsz i.succ hi x = xs.toListLitAux n hsz i ⋯ (xs.getLit i hsz ⋯ :: x) | null | true |
CategoryTheory.MorphismProperty.LeftFraction₃.hs | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
(self : W.LeftFraction₃ X Y), W self.s | the condition that the denominator belongs to the given morphism property | true |
_private.Mathlib.CategoryTheory.Sites.MorphismProperty.0.CategoryTheory.MorphismProperty.instIsStableUnderCompositionPrecoverageOfIsStableUnderComposition.match_1 | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type (max u_2 u_1)} (S : C) (X : ι → C)
(f : (i : ι) → X i ⟶ S) (σ : ι → Type (max u_2 u_1)) (Y : (i : ι) → σ i → C) (g : (i : ι) → (j : σ i) → Y i j ⟶ X i)
(motive :
(Z : C) →
(p : Z ⟶ S) →
CategoryTheory.Presieve.ofArrows (fun p... | null | false |
ContinuousMap.noConfusionType | Mathlib.Topology.ContinuousMap.Defs | Sort u →
{X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
C(X, Y) →
{X' : Type u_1} →
{Y' : Type u_2} → [inst' : TopologicalSpace X'] → [inst'_1 : TopologicalSpace Y'] → C(X', Y') → Sort u | null | false |
CategoryTheory.ShortComplex.LeftHomologyData.copy._proof_1 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) {K' : C} (eK : K' ≅ h.K),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp eK.hom h.i) S.g = 0 | null | false |
Lean.Expr.name? | Lean.Util.Recognizers | Lean.Expr → Option Lean.Name | Checks if an expression is a `Name` literal, and if so returns the name.
| true |
_private.Mathlib.RingTheory.WittVector.StructurePolynomial.0.wittStructureRat_vars._proof_1_5 | Mathlib.RingTheory.WittVector.StructurePolynomial | ∀ {idx : Type u_1} (n k : ℕ) (i : idx), ∀ j < k + 1, k ∈ Finset.range (n + 1) → (i, j).2 < n + 1 | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars.0.Lean.Meta.Grind.Arith.Cutsat.sortVars | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | Lean.Meta.Grind.GoalM (Array Int.Linear.Var) | null | true |
Measurable.coe_real_ereal | Mathlib.MeasureTheory.Constructions.BorelSpace.Real | ∀ {α : Type u_1} {mα : MeasurableSpace α} {f : α → ℝ}, Measurable f → Measurable fun x => ↑(f x) | null | true |
IsStarNormal.one_sub | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : StarRing R] {a : R} [ha : IsStarNormal a], IsStarNormal (1 - a) | null | true |
NFA.evalFrom_append | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} (M : NFA α σ) (S : Set σ) (x y : List α),
M.evalFrom S (x ++ y) = M.evalFrom (M.evalFrom S x) y | null | true |
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift._proof_4 | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
{S : CategoryTheory.Sieve X} {E : J.OneHypercover X},
E.sieve₀ ≤ S → ∀ (x : E.multicospanShape.R), S.arrows (E.f (E.multicospanShape.snd x)) | null | false |
Std.TreeMap.Raw.not_mem_diff_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → k ∉ t₁ \ t₂ | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtractAndExtendTarget.mk.congr_simp | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {outWidth w : ℕ} (x x_1 : aig.RefVec w),
x = x_1 → ∀ (h : outWidth = w * w), { w := w, x := x, h := h } = { w := w, x := x_1, h := h } | null | true |
Monoid.Coprod.fst | Mathlib.GroupTheory.Coprod.Basic | {M : Type u_1} → {N : Type u_2} → [inst : Monoid M] → [inst_1 : Monoid N] → Monoid.Coprod M N →* M | The natural projection `M ∗ N →* M`. | true |
_private.Mathlib.Analysis.RCLike.Sqrt.0.RCLike.sqrt_eq_ite._proof_1_2 | Mathlib.Analysis.RCLike.Sqrt | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], ¬RCLike.im RCLike.I = 1 → RCLike.I = 0 | null | false |
nnnorm_add_eq_nnnorm_right | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {x : E} (y : E), ‖x‖₊ = 0 → ‖x + y‖₊ = ‖y‖₊ | null | true |
PresheafOfModules.noConfusionType | Mathlib.Algebra.Category.ModuleCat.Presheaf | Sort u_1 →
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
PresheafOfModules R →
{C' : Type u₁} →
[inst' : CategoryTheory.Category.{v₁, u₁} C'] →
{R' : CategoryTheory.Functor C'ᵒᵖ RingCat} → PresheafOfModule... | null | false |
Batteries.AssocList.findEntryP?.eq_1 | Batteries.Data.AssocList | ∀ {α : Type u_1} {β : Type u_2} (p : α → β → Bool), Batteries.AssocList.findEntryP? p Batteries.AssocList.nil = none | null | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.ContDiffWithinAt.congr_of_eventuallyEq.match_1_1 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : 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] {s : Set E}
{f : E → F} {x : E} (motive : (n : WithTop ℕ∞) → ContDiffWithinAt 𝕜 n f s x → Prop) (n : WithTop ℕ∞... | null | false |
instOneNonemptyInterval | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_2} → [inst : Preorder α] → [One α] → One (NonemptyInterval α) | null | true |
MeasureTheory.integral_comp_mul_right_Ioi | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (g : ℝ → E) (a : ℝ) {b : ℝ},
0 < b → ∫ (x : ℝ) in Set.Ioi a, g (x * b) = b⁻¹ • ∫ (x : ℝ) in Set.Ioi (a * b), g x | null | true |
Units.chartAt_source | Mathlib.Geometry.Manifold.Instances.UnitsOfNormedAlgebra | ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : CompleteSpace R] {a : Rˣ}, (chartAt R a).source = Set.univ | null | true |
Module.DualBases.basis | Mathlib.LinearAlgebra.Dual.Basis | {R : Type u_1} →
{M : Type u_2} →
{ι : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] → {e : ι → M} → {ε : ι → Module.Dual R M} → Module.DualBases e ε → Module.Basis ι R M | `(h : DualBases e ε).basis` shows the family of vectors `e` forms a basis. | true |
ProfiniteGrp.coe_comp | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y Z : ProfiniteGrp.{u_1}} (f : X ⟶ Y) (g : Y ⟶ Z),
⇑(ProfiniteGrp.Hom.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(ProfiniteGrp.Hom.hom g) ∘ ⇑(ProfiniteGrp.Hom.hom f) | null | true |
Option.toArray_pmap | Init.Data.Option.Attach | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {o : Option α} {f : (a : α) → p a → β} (h : ∀ (a : α), o = some a → p a),
(Option.pmap f o h).toArray = Array.map (fun x => f ↑x ⋯) o.attach.toArray | null | true |
CategoryTheory.Limits.cokernel.mapIso | Mathlib.CategoryTheory.Limits.Shapes.Kernels | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} →
(f : X ⟶ Y) →
[inst_2 : CategoryTheory.Limits.HasCokernel f] →
{X' Y' : C} →
(f' : X' ⟶ Y') →
[inst_3 : CategoryTheory.Limi... | A commuting square of isomorphisms induces an isomorphism of cokernels. | true |
instFiniteSym | Mathlib.Data.Finite.Vector | ∀ {α : Type u_1} [Finite α] {n : ℕ}, Finite (Sym α n) | null | true |
IntermediateField.extendScalars_self | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {K : Type u_1} [inst : Field K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L] (F : IntermediateField K L),
IntermediateField.extendScalars ⋯ = ⊥ | null | true |
noConfusionTypeEnum | Init.Core | {α : Sort u} → {β : Sort v} → [inst : DecidableEq β] → (α → β) → Sort w → α → α → Sort w | Auxiliary definition for generating compact `noConfusion` for enumeration types | true |
Lean.Elab.Tactic.Grind.SimpCacheKey.mk.injEq | Lean.Elab.Tactic.Grind.Basic | ∀ (variant : Lean.Name) (extras : Array Lean.Elab.Tactic.Grind.ExtraTheorem) (variant_1 : Lean.Name)
(extras_1 : Array Lean.Elab.Tactic.Grind.ExtraTheorem),
({ variant := variant, extras := extras } = { variant := variant_1, extras := extras_1 }) =
(variant = variant_1 ∧ extras = extras_1) | null | true |
Subfield.extendScalars.orderIso._proof_5 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {L : Type u_1} [inst : Field L] (F : Subfield L) (E : IntermediateField (↥F) L) (x : L) (hx : x ∈ F),
(algebraMap (↥F) L) ⟨x, hx⟩ ∈ E | null | false |
AlgebraicGeometry.Scheme.Hom.asFiberHom_fiberι_assoc | Mathlib.AlgebraicGeometry.Fiber | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (x : ↥X) {Z : AlgebraicGeometry.Scheme} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.asFiberHom f x)
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.fiberι f (f x)) h) =
CategoryTheory.CategoryStruct.comp (X.fr... | null | true |
Lean.Lsp.SemanticTokenType.leanSorryLike | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SemanticTokenType | null | true |
CategoryTheory.Limits.Cocone.extendComp | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
(s : CategoryTheory.Limits.Cocone F) →
{X Y : C} →
(g : s.pt ⟶ Y) → (f : Y ⟶ X) → s.extend (CategoryThe... | Extending a cocone by a composition is the same as extending the cone twice. | true |
Topology.CWComplex.noConfusion | Mathlib.Topology.CWComplex.Classical.Basic | {P : Sort u_1} →
{X : Type u} →
{inst : TopologicalSpace X} →
{C : Set X} →
{t : Topology.CWComplex C} →
{X' : Type u} →
{inst' : TopologicalSpace X'} →
{C' : Set X'} →
{t' : Topology.CWComplex C'} →
X = X' → inst ≍ inst' → C ≍ C'... | null | false |
Std.DTreeMap.Raw.Const.mem_iff_isSome_get? | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α}, a ∈ t ↔ (Std.DTreeMap.Raw.Const.get? t a).isSome = true | null | true |
AddCon.eq | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) {a b : M}, ↑a = ↑b ↔ c a b | Two elements are related by an additive congruence relation `c` iff
they are represented by the same element of the quotient by `c`. | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.insertListIfNew.eq_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (l : List ((a : α) × β a)) (k : α) (v : β k)
(l_1 : List ((a : α) × β a)),
Std.Internal.List.insertListIfNew l (⟨k, v⟩ :: l_1) =
Std.Internal.List.insertListIfNew (Std.Internal.List.insertEntryIfNew k v l) l_1 | null | true |
instRingWithIdealFilter._proof_36 | Mathlib.RingTheory.IdealFilter.Topology | ∀ {A : Type u_1} [inst : Ring A] (x : IdealFilter A),
autoParam (∀ (a b : WithIdealFilter x), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
HomologicalComplex.isoHomologyι_hom_inv_id_assoc | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i j : ι) (hj : c.next i = j) (h : K.d i j = 0)
[inst_2 : K.HasHomology i] {Z : C} (h_1 : K.homology i ⟶ Z),
CategoryTheory.CategorySt... | null | true |
Units.liftRight.congr_simp | Mathlib.RingTheory.Localization.Away.Basic | ∀ {M : Type u} {N : Type v} [inst : Monoid M] [inst_1 : Monoid N] (f f_1 : M →* N) (e_f : f = f_1) (g g_1 : M → Nˣ)
(e_g : g = g_1) (h : ∀ (x : M), ↑(g x) = f x), Units.liftRight f g h = Units.liftRight f_1 g_1 ⋯ | null | true |
AddAction.mem_orbit_symm | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {a₁ a₂ : α},
a₁ ∈ AddAction.orbit G a₂ ↔ a₂ ∈ AddAction.orbit G a₁ | null | true |
Std.DTreeMap.Internal.Impl.keysArray_filter_key | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {f : α → Bool} (h : t.WF),
(Std.DTreeMap.Internal.Impl.filter (fun k x => f k) t ⋯).impl.keysArray = Array.filter f t.keysArray | null | true |
ZetaAsymptotics.zeta_limit_aux1 | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ {s : ℝ}, 1 < s → ∑' (n : ℕ), 1 / (↑n + 1) ^ s - 1 / (s - 1) = 1 - s * ZetaAsymptotics.termTSum s | Reformulation of `ZetaAsymptotics.termTSum_of_lt` which is useful for some computations
below. | true |
Subfield.copy._proof_6 | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u_1} [inst : DivisionRing K] (S : Subfield K) (s : Set K), s = ↑S → ∀ x ∈ s, x⁻¹ ∈ s | null | false |
coe_convexAddSubmonoid | Mathlib.Analysis.Convex.Basic | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E], ↑(convexAddSubmonoid 𝕜 E) = {s | Convex 𝕜 s} | null | true |
_private.Mathlib.Data.Set.Restrict.0.Set.injective_codRestrict._simp_1_1 | Mathlib.Data.Set.Restrict | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
RBTree.RBNode.cmpEq_iff | BatteriesRecycling.RBTree.Basic | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x y : α} [Std.TransCmp cmp],
RBTree.RBNode.cmpEq cmp x y ↔ cmp x y = Ordering.eq | null | true |
List.max?_eq_some_iff' | Init.Data.List.Nat.Basic | ∀ {a : ℕ} {xs : List ℕ}, xs.max? = some a ↔ a ∈ xs ∧ ∀ b ∈ xs, b ≤ a | null | true |
ULift.seminormedCommRing._proof_6 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (n : ℕ) (x : ULift.{u_1, u_2} α),
Monoid.npow (n + 1) x = Monoid.npow n x * x | null | false |
Nat.Linear.ExprCnstr.denote | Init.Data.Nat.Linear | Nat.Linear.Context → Nat.Linear.ExprCnstr → Prop | null | true |
Std.Async.UDP.Socket.bind | Std.Async.UDP | Std.Async.UDP.Socket → Std.Net.SocketAddress → IO Unit | Binds the UDP socket to the given address. Address reuse is enabled to allow rebinding the
same address.
| true |
CategoryTheory.Abelian.SpectralObject.Hom.casesOn | Mathlib.Algebra.Homology.SpectralObject.Basic | {C : Type u_1} →
{ι : Type u_2} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Category.{u_4, u_2} ι] →
[inst_2 : CategoryTheory.Abelian C] →
{X X' : CategoryTheory.Abelian.SpectralObject C ι} →
{motive : X.Hom X' → Sort u} →
(t : X.Hom... | null | false |
Int.clog_zero_left | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] (r : R), Int.clog 0 r = 0 | null | true |
CategoryTheory.instCreatesFiniteLimitsIndFunctorOppositeTypeInclusionOfHasFiniteLimits | Mathlib.CategoryTheory.Limits.Indization.Category | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasFiniteLimits C] →
CategoryTheory.Limits.CreatesFiniteLimits (CategoryTheory.Ind.inclusion C) | null | true |
Std.TreeMap.Raw.get?_diff | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, (t₁ \ t₂).get? k = if k ∈ t₂ then none else t₁.get? k | null | true |
Matroid.finitary_iff_forall_isCircuit_finite | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α}, M.Finitary ↔ ∀ (C : Set α), M.IsCircuit C → C.Finite | null | true |
CategoryTheory.Limits.Multicoequalizer.condition | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) [inst_1 : CategoryTheory.Limits.HasMulticoequalizer I] (a : J.L),
CategoryTheory.CategoryStruct.comp (I.fst a) (CategoryTheory.Limits.Multicoequalizer.π I (J.fst a)) =
... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.