name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Multiset.sum_map_singleton | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {M : Type u_5} (s : Multiset M), (Multiset.map (fun a => {a}) s).sum = s | null | true |
RingCat.moduleCatRestrictScalarsPseudofunctor._proof_1 | Mathlib.Algebra.Category.ModuleCat.Pseudofunctor | ∀ {b₀ b₁ b₂ b₃ : RingCatᵒᵖ} (f : b₀ ⟶ b₁) (g : b₁ ⟶ b₂) (h : b₂ ⟶ b₃),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Cat.Hom.isoMk
(ModuleCat.restrictScalarsComp (RingCat.Hom.hom h.unop)
(RingCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g).unop))).hom
(CategoryTheory.Catego... | null | false |
_private.Mathlib.Algebra.Polynomial.Lifts.0.Polynomial.exists_support_eq_of_mem_lifts._simp_1_6 | Mathlib.Algebra.Polynomial.Lifts | ∀ {a b : Prop}, (¬a → ¬b) = (b → a) | null | false |
_private.Lean.Util.SortExprs.0.Lean.sortExprs.match_3 | Lean.Util.SortExprs | (motive : ℕ × Lean.Perm → Sort u_1) → (x : ℕ × Lean.Perm) → ((i : ℕ) → (perm : Lean.Perm) → motive (i, perm)) → motive x | null | false |
Inclusion.HypothesisExt.family | Mathlib.Tactic.Inclusion.Core.Extensions | Inclusion.HypothesisExt → Lean.Name | The family in which the extension is registered. | true |
Field.absoluteGaloisGroup | Mathlib.FieldTheory.AbsoluteGaloisGroup | (K : Type u_1) → [Field K] → Type u_1 | The absolute Galois group of `K`, defined as the Galois group of the field extension `K^al/K`,
where `K^al` is an algebraic closure of `K`. | true |
Asymptotics.isLittleOTVS_iff | Mathlib.Analysis.Asymptotics.TVS | ∀ (𝕜 : Type u_1) {α : Type u_2} {E : Type u_3} {F : Type u_4} [inst : ENorm 𝕜] [inst_1 : TopologicalSpace E]
[inst_2 : TopologicalSpace F] [inst_3 : Zero E] [inst_4 : Zero F] [inst_5 : SMul 𝕜 E] [inst_6 : SMul 𝕜 F]
(l : Filter α) (f : α → E) (g : α → F),
f =o[𝕜; l] g ↔
∀ U ∈ nhds 0, ∃ V ∈ nhds 0, ∀ (ε : ... | null | true |
NormedRing.induced._proof_9 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_3} (R : Type u_1) (S : Type u_2) [inst : FunLike F R S] [inst_1 : Ring R] [inst_2 : NormedRing S]
[NonUnitalRingHomClass F R S] (f : F) (a b : R), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
UniformCauchySeqOn.fun_neg | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3}
{l : Filter ι} {f : ι → β → α} {s : Set β}, UniformCauchySeqOn f l s → UniformCauchySeqOn (fun i i_1 => -f i i_1) l s | Eta-expanded form of `UniformCauchySeqOn.neg` | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.trapezoidal_error_le_of_lt._simp_1_7 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
OrderDual.instConditionallyCompletePartialOrder | Mathlib.Order.ConditionallyCompletePartialOrder.Basic | {α : Type u_1} → [ConditionallyCompletePartialOrder α] → ConditionallyCompletePartialOrder αᵒᵈ | null | true |
CategoryTheory.AddMon.monMonoidal._proof_7 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y : CategoryTheory.AddMon C),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.CategoryStruct.id Y) =
CategoryTheory.CategoryStruct.id (Ca... | null | false |
birkhoffSum_zero | Mathlib.Dynamics.BirkhoffSum.Basic | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] (f : α → α) (g : α → M), birkhoffSum f g 0 = 0 | null | true |
Lean.Parser.symbolNoAntiquot | Lean.Parser.Basic | String → Lean.Parser.Parser | null | true |
Int8.reduceOfIntLE | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | Lean.Meta.Simp.DSimproc | null | true |
HomologicalComplex.truncLEXIso | Mathlib.Algebra.Homology.Embedding.TruncLE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(K : HomologicalComplex C c') →
(e : c.Embeddi... | The isomorphism `(K.truncLE e).X i' ≅ K.X i'` when `e.f i = i'`
and `e.BoundaryLE i` does not hold. | true |
_private.Mathlib.Topology.Constructions.SumProd.0.Prod.instNeBotNhdsWithinIio.match_1 | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u_1} {Y : Type u_2} [inst : Preorder X] [inst_1 : Preorder Y] {x : X × Y} (x_1 : X × Y)
(motive : x_1 ∈ Set.Iio x.1 ×ˢ Set.Iio x.2 → Prop) (x_2 : x_1 ∈ Set.Iio x.1 ×ˢ Set.Iio x.2),
(∀ (h₁ : x_1.1 ∈ Set.Iio x.1) (h₂ : x_1.2 ∈ Set.Iio x.2), motive ⋯) → motive x_2 | null | false |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.FixedPoints.0.UpperHalfPlane.gl_smul_eq_iff_num_eq._simp_1_2 | Mathlib.Analysis.Complex.UpperHalfPlane.FixedPoints | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b c : G₀}, b ≠ 0 → (a / b = c) = (a = c * b) | null | false |
_private.Mathlib.Topology.UniformSpace.Separation.0.t0Space_iff_ker_uniformity._simp_1_3 | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u_1} {s : Set (α × α)}, (Set.diagonal α ⊆ s) = ∀ (x : α), (x, x) ∈ s | null | false |
AddMonoid.Coprod.clift._proof_2 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass P] (f : FreeAddMonoid (M ⊕ N) →+ P),
f (FreeAddMonoid.of (Sum.inl 0)) = 0 →
f (FreeAddMonoid.of (Sum.inr 0)) = 0 →
(∀ (x y : M),
f (FreeAddMonoid.of (Sum.inl (x + y))) = f (Fre... | null | false |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.getMatchLoop._unsafe_rec | Lean.Meta.Sym.Simp.DiscrTree | {α : Type} → Lean.MetavarContext → Array Lean.Expr → Lean.Meta.DiscrTree.Trie α → Array α → Array α | null | false |
CategoryTheory.Limits.WalkingMulticospan.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {P : Sort u} →
{J : CategoryTheory.Limits.MulticospanShape} →
{t : CategoryTheory.Limits.WalkingMulticospan J} →
{J' : CategoryTheory.Limits.MulticospanShape} →
{t' : CategoryTheory.Limits.WalkingMulticospan J'} →
J = J' → t ≍ t' → CategoryTheory.Limits.WalkingMulticospan.noConfusionType P... | null | false |
_private.Mathlib.Analysis.MellinInversion.0.mellin_eq_fourier._simp_1_2 | Mathlib.Analysis.MellinInversion | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
ContinuousAlgEquiv.coe_inj | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] {f g : A ≃A[R] B}, ↑f = ↑g ↔ f = g | null | true |
Std.DTreeMap.getD_alter_self | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {k : α} {fallback : β k} {f : Option (β k) → Option (β k)},
(t.alter k f).getD k fallback = (f (t.get? k)).getD fallback | null | true |
SeparationQuotient.instAddCommMonoid.eq_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddCommMonoid M] [inst_2 : ContinuousAdd M],
SeparationQuotient.instAddCommMonoid = { toAddMonoid := SeparationQuotient.instAddMonoid, add_comm := ⋯ } | null | true |
Affine.Simplex.height_pos | Mathlib.Geometry.Euclidean.Altitude | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
0 < s.height i | null | true |
CategoryTheory.PreOneHypercover.instCategory._proof_4 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} {X Y : CategoryTheory.PreOneHypercover S}
(f : X.Hom Y), f.comp (CategoryTheory.PreOneHypercover.Hom.id Y) = f | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CFC.sqrt_ringInverse._proof_1_13 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A] [inst_5 : Algebra ℝ A]
[inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint], NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint | null | false |
BitVec.smtSDiv.eq_1 | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x y : BitVec n),
x.smtSDiv y =
match x.msb, y.msb with
| false, false => x.smtUDiv y
| false, true => (x.smtUDiv y.neg).neg
| true, false => (x.neg.smtUDiv y).neg
| true, true => x.neg.smtUDiv y.neg | null | true |
IsFractionRing.num_mul_den_eq_num_iff_eq | Mathlib.RingTheory.Localization.NumDen | ∀ {A : Type u_1} [inst : CommRing A] [inst_1 : IsDomain A] [inst_2 : UniqueFactorizationMonoid A] {K : Type u_2}
[inst_3 : Field K] [inst_4 : Algebra A K] [inst_5 : IsFractionRing A K] {x y : K},
x * (algebraMap A K) ↑(IsFractionRing.den A y) = (algebraMap A K) (IsFractionRing.num A y) ↔ x = y | null | true |
AddMonoid.neZero_exponent_of_finite | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : AddLeftCancelMonoid G] [Finite G], NeZero (AddMonoid.exponent G) | null | true |
_private.Mathlib.Topology.AlexandrovDiscrete.0.Prod.instAlexandrovDiscrete._simp_3 | Mathlib.Topology.AlexandrovDiscrete | ∀ {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] (a : α), nhds a = Filter.principal (nhdsKer {a}) | null | false |
Configuration.ProjectivePlane.instDual._proof_1 | Mathlib.Combinatorics.Configuration | ∀ (P : Type u_2) (L : Type u_1) [inst : Membership P L] [inst_1 : Configuration.ProjectivePlane P L]
{p₁ p₂ : Configuration.Dual L} (h : p₁ ≠ p₂),
p₁ ∈ Configuration.HasLines.mkLine h ∧ p₂ ∈ Configuration.HasLines.mkLine h | null | false |
Real.normedCommRing._proof_14 | Mathlib.Analysis.Normed.Ring.Basic | ∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1) | null | false |
exists_Ioc_subset_of_mem_nhds | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] {a : α} {s : Set α},
s ∈ nhds a → (∃ l, l < a) → ∃ l < a, Set.Ioc l a ⊆ s | null | true |
Lean.Meta.InjectionResult.recOn | Lean.Meta.Tactic.Injection | {motive : Lean.Meta.InjectionResult → Sort u} →
(t : Lean.Meta.InjectionResult) →
motive Lean.Meta.InjectionResult.solved →
((mvarId : Lean.MVarId) →
(newEqs : Array Lean.FVarId) →
(remainingNames : List Lean.Name) →
motive (Lean.Meta.InjectionResult.subgoal mvarId newEqs... | null | false |
ContIntertwiningMap.toFun_injective | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {R : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Monoid G] [inst_1 : Ring R]
[inst_2 : AddCommGroup V] [inst_3 : TopologicalSpace V] [inst_4 : IsTopologicalAddGroup V] [inst_5 : Module R V]
[inst_6 : AddCommGroup W] [inst_7 : TopologicalSpace W] [inst_8 : IsTopologicalAddGroup W] [inst_9 : Modu... | null | true |
CategoryTheory.Limits.DiagramOfCocones.coconePoints | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} →
Cat... | Extract the functor `J ⥤ C` consisting of the cocone points and the maps between them,
from a `DiagramOfCocones`.
| true |
SupPrime.le_sup | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : SemilatticeSup α] {a b c : α}, SupPrime a → (a ≤ b ⊔ c ↔ a ≤ b ∨ a ≤ c) | null | true |
WithBot.instMulZeroOneClass._proof_5 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroOneClass α] (a : WithBot α), 0 * a = 0 | null | false |
ENNReal.continuous_rpow_const | Mathlib.Analysis.SpecialFunctions.Pow.Continuity | ∀ {y : ℝ}, Continuous fun a => a ^ y | null | true |
Lean.Lsp.instFromJsonClientInfo.fromJson | Lean.Data.Lsp.InitShutdown | Lean.Json → Except String Lean.Lsp.ClientInfo | null | true |
GaloisConnection.l_iSup | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] {l : α → β}
{u : β → α}, GaloisConnection l u → ∀ {f : ι → α}, l (iSup f) = ⨆ i, l (f i) | null | true |
LinearMap.applyₗ'_apply_apply | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_1} (S : Type u_3) {M : Type u_4} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module S M₂] [inst_7 : SMulCommClass R S M₂] (v : M) (f : M →ₗ[R] M₂), ((LinearMap.applyₗ' S) v) f = ... | null | true |
CategoryTheory.Functor.homEquivOfIsRightKanExtension._proof_1 | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_4} {D : Type u_6} [inst : CategoryTheory.Category.{u_3, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} H] [inst_2 : CategoryTheory.Category.{u_5, u_6} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : L.comp F' ⟶ F) [inst... | null | false |
Nat.pincerRecursion._unary._proof_3 | Mathlib.Data.Nat.Init | ∀ (n n_1 : ℕ),
(invImage (fun x => PSigma.casesOn x fun n m => (n, m)) Prod.instWellFoundedRelation).1 ⟨n.succ, n_1⟩
⟨n.succ, n_1.succ⟩ | null | false |
MeasureTheory.exists_measure_iInter_lt | Mathlib.MeasureTheory.Measure.Continuity | ∀ {α : Type u_1} {ι : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : ι → Set α}
[inst : SemilatticeSup ι] [Countable ι],
(∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) →
∀ {ε : ENNReal}, 0 < ε → (∃ i, μ (s i) ≠ ⊤) → ⋂ n, s n = ∅ → ∃ m_1, μ (⋂ n, ⋂ (_ : n ≤ m_1), s n) < ε | Some version of continuity of a measure in the empty set using the intersection along a set of
sets. | true |
Lean.Meta.Grind.CasesTypes.mk._flat_ctor | Lean.Meta.Tactic.Grind.Extension | Lean.PHashMap Lean.Name Bool → Lean.Meta.Grind.CasesTypes | null | false |
ConditionallyCompleteLattice.isGLB_csInf | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ {α : Type u_2} [self : ConditionallyCompleteLattice α] (s : Set α), s.Nonempty → BddBelow s → IsGLB s (sInf s) | Every nonempty subset which is bounded below has a greatest lower bound. | true |
Matrix.nondegenerate_toBilin_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} {M₂ : Type u_4} [inst : CommRing R₂] [inst_1 : AddCommGroup M₂] [inst_2 : Module R₂ M₂] {ι : Type u_6}
[inst_3 : DecidableEq ι] [inst_4 : Fintype ι] {M : Matrix ι ι R₂} (b : Module.Basis ι R₂ M₂),
((Matrix.toBilin b) M).Nondegenerate = M.Nondegenerate | null | false |
_private.Lean.Elab.Tactic.Conv.Pattern.0.Lean.Elab.Tactic.Conv.matchPattern?.match_1 | Lean.Elab.Tactic.Conv.Pattern | (motive : Lean.Expr × Array Lean.Expr → Sort u_1) →
(x : Lean.Expr × Array Lean.Expr) → ((f : Lean.Expr) → (extra : Array Lean.Expr) → motive (f, extra)) → motive x | null | false |
Ordinal.lift_umax | Mathlib.SetTheory.Ordinal.Basic | Ordinal.lift.{max u v, u} = Ordinal.lift.{v, u} | `lift.{max u v, u}` equals `lift.{v, u}`.
Unfortunately, the simp lemma doesn't seem to work. | true |
CategoryTheory.Abelian.toIsNormalMonoCategory | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Abelian C],
CategoryTheory.IsNormalMonoCategory C | null | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsSemilinearSet.diff | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s₁ s₂ : Set M},
IsSemilinearSet s₁ → IsSemilinearSet s₂ → IsSemilinearSet (s₁ \ s₂) | **Alias** of `IsSemilinearSet.sdiff`.
---
Semilinear sets are closed under set difference. | true |
_private.Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape.0.CategoryTheory.ObjectProperty.limitsOfShape_le_of_initial.match_1_1 | Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] (P : CategoryTheory.ObjectProperty C) {J' : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} J'] (_h : C) (motive : P.limitsOfShape J' _h → Prop)
(x : P.limitsOfShape J' _h), (∀ (h : P.LimitOfShape J' _h), motive ⋯) → motive x | null | false |
Mathlib.Tactic.Translate.Config.mk.injEq | Mathlib.Tactic.Translate.Core | ∀ (trace : Bool) (target : Lean.Name) (doc : Option (Lean.TSyntax `Lean.Parser.Command.docComment))
(allowAutoName : Bool) (reorder? : Option Mathlib.Tactic.Translate.ArgReorder)
(relevantArg? : Option Mathlib.Tactic.Translate.RelevantArg) (attrs : Array Lean.Syntax) (dontTranslate : List ℕ)
(ref : Lean.Syntax) (... | null | true |
Real.self_le_arctan | Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds | ∀ {x : ℝ}, x ≤ 0 → x ≤ Real.arctan x | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.interSmallerFn.match_1.eq_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} (motive : Option ((a : α) × β a) → Sort u_3) (kv' : (a : α) × β a)
(h_1 : (kv' : (a : α) × β a) → motive (some kv')) (h_2 : Unit → motive none),
(match some kv' with
| some kv' => h_1 kv'
| none => h_2 ()) =
h_1 kv' | null | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.IsAtom.congr_simp | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] {inst_1 : DecidableEq G} [inst_2 : DecidableEq G] (K K_1 : ℝ),
K = K_1 →
∀ (S S_1 : Finset G), S = S_1 → ∀ (A A_1 : Finset G), A = A_1 → Finset.IsAtom✝ K S A = Finset.IsAtom✝ K_1 S_1 A_1 | null | true |
CategoryTheory.Functor.isContinuous_iff_coverPreserving | Mathlib.CategoryTheory.Sites.CoverPreserving | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {J : CategoryTheory.GrothendieckTopology C}
{K : CategoryTheory.GrothendieckTopology D} [CategoryTheory.RepresentablyFlat F],
F.IsContinuous J K ↔ CategoryTheory... | If `F` is flat, it is continuous if and only if it preserves covers. | true |
Lean.Compiler.LCNF.SpecParamInfo._sizeOf_1 | Lean.Compiler.LCNF.SpecInfo | Lean.Compiler.LCNF.SpecParamInfo → ℕ | null | false |
InfHom.instSemilatticeInf._proof_2 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : SemilatticeInf β] {x y : InfHom α β}, ⇑y ≤ ⇑x ↔ ⇑y ≤ ⇑x | null | false |
Lean.Lsp.DocumentChange.rename | Lean.Data.Lsp.Basic | Lean.Lsp.RenameFile → Lean.Lsp.DocumentChange | null | true |
_private.Mathlib.MeasureTheory.Integral.CircleIntegral.0.CircleIntegrable.congr_codiscreteWithin._simp_1_1 | Mathlib.MeasureTheory.Integral.CircleIntegral | ∀ {α : Type u} (s : Set α), (s ⊆ Set.univ) = True | null | false |
intervalIntegral.integral_Iic_sub_Iic | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {f : ℝ → E}
{μ : MeasureTheory.Measure ℝ},
MeasureTheory.IntegrableOn f (Set.Iic a) μ →
MeasureTheory.IntegrableOn f (Set.Iic b) μ →
∫ (x : ℝ) in Set.Iic b, f x ∂μ - ∫ (x : ℝ) in Set.Iic a, f x ∂μ = ∫ (x : ℝ) in a..b, f x ... | null | true |
ModularForm.Λ.eq_1 | Mathlib.NumberTheory.ModularForms.LFunction | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [inst : Γ.IsArithmetic] {k : ℤ} (hk : 0 < k) {F : Type u_1}
[inst_1 : FunLike F UpperHalfPlane ℂ] (f : F) [inst_2 : ModularFormClass F Γ k],
ModularForm.Λ hk f = (ModularForm.weakFEPair hk f).Λ | null | true |
dist_pi_const | Mathlib.Topology.MetricSpace.Pseudo.Pi | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : Fintype β] [Nonempty β] (a b : α),
(dist (fun x => a) fun x => b) = dist a b | null | true |
Sum.Ioc_inl_inr | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (a₁ : α) (b₂ : β), Finset.Ioc (Sum.inl a₁) (Sum.inr b₂) = ∅ | null | true |
groupHomology.π | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] → (A : Rep.{u, u, u} k G) → (n : ℕ) → groupHomology.cycles A n ⟶ groupHomology A n | The natural map from `n`-cycles to `n`th group homology for a `k`-linear
`G`-representation `A`. | true |
ContinuousMap.HomotopyEquiv.ctorIdx | Mathlib.Topology.Homotopy.Equiv | {X : Type u} →
{Y : Type v} → {inst : TopologicalSpace X} → {inst_1 : TopologicalSpace Y} → ContinuousMap.HomotopyEquiv X Y → ℕ | null | false |
Lean.IR.EmitLLVM.callLeanAllocCtor | Lean.Compiler.IR.EmitLLVM | {llvmctx : Lean.LLVM.Context} →
Lean.LLVM.Builder llvmctx → ℕ → ℕ → ℕ → optParam String "" → Lean.IR.EmitLLVM.M llvmctx (Lean.LLVM.Value llvmctx) | null | true |
Module.End.mapsTo_maxGenEigenspace_of_comm | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f g : Module.End R M},
Commute f g → ∀ (μ : R), Set.MapsTo ⇑g ↑(f.maxGenEigenspace μ) ↑(f.maxGenEigenspace μ) | null | true |
Antivary.pow_left₀ | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α]
[inst_3 : PartialOrder β] {f : ι → α} {g : ι → β}, 0 ≤ f → Antivary f g → ∀ (n : ℕ), Antivary (f ^ n) g | null | true |
CategoryTheory.EffectiveEquivalenceRelation.mk.inj | Mathlib.CategoryTheory.EquivalenceRelation | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {R A : C} {p₁ p₂ : R ⟶ A}
{toEquivalenceRelation : CategoryTheory.EquivalenceRelation p₁ p₂} {B : C} {π : A ⟶ B}
{isKernelPair : CategoryTheory.IsKernelPair π p₁ p₂} {isPushout : CategoryTheory.IsPushout p₁ p₂ π π}
{toEquivalenceRelation_1 : CategoryT... | null | true |
pow_le_one_iff_of_nonneg | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a : M₀} {n : ℕ}
[ZeroLEOneClass M₀], 0 ≤ a → n ≠ 0 → (a ^ n ≤ 1 ↔ a ≤ 1) | null | true |
_private.Init.Data.String.Basic.0.String.Pos.Raw.isValid_ofList._simp_1_2 | Init.Data.String.Basic | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Dual.0.InnerProductSpace.«_aux_Mathlib_Analysis_InnerProductSpace_Dual___macroRules__private_Mathlib_Analysis_InnerProductSpace_Dual_0_InnerProductSpace_term⟪_,_⟫_1_1» | Mathlib.Analysis.InnerProductSpace.Dual | Lean.Macro | null | false |
CochainComplex.Plus.fibrantObjectEquivalence._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.DerivabilityStructureInjectives | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(K : CochainComplex.Plus (CategoryTheory.InjectiveObject C)),
HomotopicalAlgebra.fibrantObjects (CochainComplex.Plus C)
((CategoryTheory.InjectiveObject.ι C).mapCochainComplexPlus.obj K) | null | false |
CategoryTheory.Span.SpanBicat.leftUnitor | Mathlib.CategoryTheory.Bicategory.Span.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{Wₗ Wᵣ : CategoryTheory.MorphismProperty C} →
[inst_1 : Wₗ.ContainsIdentities] →
[inst_2 : Wᵣ.ContainsIdentities] →
[inst_3 : Wₗ.HasPullbacksAgainst Wᵣ] →
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] →
... | The left unitor for the bicategory structure on spans. | true |
MeasurableEquiv.mulLeft | Mathlib.MeasureTheory.Group.MeasurableEquiv | {G : Type u_1} → [inst : Group G] → [inst_1 : MeasurableSpace G] → [MeasurableMul G] → G → G ≃ᵐ G | If `G` is a group with measurable multiplication, then left multiplication by `g : G` is a
measurable automorphism of `G`. | true |
GaloisCoinsertion.u_iSup_l | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_2} {u : α → β} {l : β → α} [inst : CompleteLattice α] [inst_1 : CompleteLattice β]
(gi : GaloisCoinsertion l u) {ι : Sort x} (f : ι → β), u (⨆ i, l (f i)) = ⨆ i, f i | null | true |
CategoryTheory.IsAddMonHom.Normal.isAddMonHom._autoParam | Mathlib.CategoryTheory.Monoidal.Cartesian.Normal | Lean.Syntax | null | false |
pow_apply | Mathlib.Algebra.Group.IsApply | ∀ {M : Type u_1} {F : Type u_2} {α : outParam (Type u_3)} {β : outParam (Type u_4)} {inst : FunLike F α β}
{inst_1 : Pow β M} {inst_2 : Pow F M} [self : IsPowApply M F α β] (f : F) (n : M) (x : α), (f ^ n) x = f x ^ n | **Alias** of `IsPowApply.pow_apply`. | true |
Lean.Data.AC.Context.mk._flat_ctor | Init.Data.AC | {α : Sort u} →
(op : α → α → α) →
Std.Associative op →
Option (PLift (Std.Commutative op)) →
Option (PLift (Std.IdempotentOp op)) → List (Lean.Data.AC.Variable op) → α → Lean.Data.AC.Context α | null | false |
Lean.Compiler.LCNF.instTraverseFVarExpr | Lean.Compiler.LCNF.FVarUtil | Lean.Compiler.LCNF.TraverseFVar Lean.Expr | null | true |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.size_insertExtractMax._proof_1_4 | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} [inst : Ord α] (heap : Batteries.BinaryHeap α) (x : α), (heap.insertExtractMax x).2.size = heap.size | null | false |
AddChar._sizeOf_inst | Mathlib.Algebra.Group.AddChar | (A : Type u_1) →
{inst : AddMonoid A} → (M : Type u_2) → {inst_1 : Monoid M} → [SizeOf A] → [SizeOf M] → SizeOf (AddChar A M) | null | false |
Vector.getElem?_append | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m : ℕ} {xs : Vector α n} {ys : Vector α m} {i : ℕ},
(xs ++ ys)[i]? = if i < n then xs[i]? else ys[i - n]? | null | true |
UInt16.eq_of_toFin_eq | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, a.toFin = b.toFin → a = b | null | true |
IntermediateField.algHomEquivAlgHomOfSplits_apply | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {F : Type u_1} {K : Type u_2} (A : Type u_3) [inst : Field F] [inst_1 : Field K] [inst_2 : Field A]
[inst_3 : Algebra F K] [inst_4 : Algebra F A] [inst_5 : Algebra.IsAlgebraic F K] (L : IntermediateField F A)
(hL : ∀ (x : K), (Polynomial.map (algebraMap F ↥L) (minpoly F x)).Splits) (φ₂ : K →ₐ[F] ↥L),
(Intermedi... | null | true |
StateT.run_pure | Init.Control.Lawful.Instances | ∀ {m : Type u_1 → Type u_2} {α σ : Type u_1} [inst : Monad m] (a : α) (s : σ), (pure a).run s = pure (a, s) | null | true |
transpose_mem_doublyStochastic_iff | Mathlib.Analysis.Convex.DoublyStochasticMatrix | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {M : Matrix n n R},
M.transpose ∈ doublyStochastic R n ↔ M ∈ doublyStochastic R n | A matrix is doubly stochastic iff its transpose is doubly stochastic | true |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.cmp_to_nat.match_1_1 | Mathlib.Data.Num.Lemmas | ∀ (motive : PosNum → PosNum → Prop) (x x_1 : PosNum),
(∀ (_ : Unit), motive PosNum.one PosNum.one) →
(∀ (a : PosNum), motive a.bit0 PosNum.one) →
(∀ (a : PosNum), motive a.bit1 PosNum.one) →
(∀ (b : PosNum), motive PosNum.one b.bit0) →
(∀ (b : PosNum), motive PosNum.one b.bit1) →
... | null | false |
LieRinehartAlgebra.anchor._proof_2 | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ (R : Type u_1) (A₁ : Type u_2) [inst : CommRing R] [inst_1 : CommRing A₁] [inst_2 : Algebra R A₁],
SMulCommClass R A₁ A₁ | null | false |
Std.ExtDTreeMap.getKey!_union | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α}, (t₁ ∪ t₂).getKey! k = t₂.getKeyD k (t₁.getKey! k) | null | true |
Lists'.noConfusionType | Mathlib.SetTheory.Lists | Sort u_1 → {α : Type u} → {a : Bool} → Lists' α a → {α' : Type u} → {a' : Bool} → Lists' α' a' → Sort u_1 | null | false |
Nat.card_pos | Mathlib.SetTheory.Cardinal.Finite | ∀ {α : Type u_1} [Nonempty α] [Finite α], 0 < Nat.card α | null | true |
CategoryTheory.yonedaGrpObjIsoOfRepresentableBy | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
(X : C) →
(F : CategoryTheory.Functor Cᵒᵖ GrpCat) →
(α : (F.comp (CategoryTheory.forget GrpCat)).RepresentableBy X) → CategoryTheory.yonedaGrpObj X ≅ F | If `X` represents a presheaf of groups `F`, then `Hom(-, X)` is isomorphic to `F` as
a presheaf of groups. | true |
_private.Mathlib.NumberTheory.ClassNumber.Finite.0.ClassGroup.exists_mem_finsetApprox._simp_1_8 | Mathlib.NumberTheory.ClassNumber.Finite | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.