name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Tactic.BicategoryLike.MkEqOfNaturality.casesOn | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MkEqOfNaturality m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MkEqOfNaturality m) →
((mkEqOfNaturality :
Lean.Expr →
Lean.Expr →
Mathlib.Tactic.BicategoryLike.IsoLift →
Mathlib.Tactic.... | null | false |
MultilinearMap.dfinsuppFamily._proof_6 | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {ι : Type u_1} {κ : ι → Type u_2} {R : Type u_5} {M : (i : ι) → κ i → Type u_3} {N : ((i : ι) → κ i) → Type u_4}
[inst : DecidableEq ι] [inst_1 : Fintype ι] [inst_2 : Semiring R]
[inst_3 : (i : ι) → (k : κ i) → AddCommMonoid (M i k)] [inst_4 : (p : (i : ι) → κ i) → AddCommMonoid (N p)]
[inst_5 : (i : ι) → (k : ... | null | false |
Batteries.PairingHeapImp.Heap.NodeWF._sunfold | Batteries.Data.PairingHeap | {α : Type u_1} → (α → α → Bool) → α → Batteries.PairingHeapImp.Heap α → Prop | null | false |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems | Lean.Elab.Tactic.Do.Attr | Type | null | true |
Set.tprod.eq_def | Mathlib.Data.Prod.TProd | ∀ {ι : Type u} {α : ι → Type v} (x : List ι) (x_1 : (i : ι) → Set (α i)),
Set.tprod x x_1 =
match x, x_1 with
| [], x => Set.univ
| i :: is, t => t i ×ˢ Set.tprod is t | null | true |
Aesop.SimpResult.simplified | Aesop.Search.Expansion.Simp | Lean.MVarId → Lean.Meta.Simp.UsedSimps → Aesop.SimpResult | null | true |
Real.sInf_nonpos | Mathlib.Algebra.Order.Archimedean.Real.Basic | ∀ {s : Set ℝ}, (∀ x ∈ s, x ≤ 0) → sInf s ≤ 0 | As `sInf s = 0` when `s` is a set of reals that's either empty or unbounded below,
it suffices to show that all elements of `s` are nonpositive to show that `sInf s ≤ 0`. | true |
_private.Init.Data.Array.InsertionSort.0.Array.insertionSort.swapLoop._proof_1 | Init.Data.Array.InsertionSort | ∀ {α : Type u_1} (xs : Array α), ∀ j < xs.size, ∀ (j' : ℕ), j = j'.succ → j' < xs.size | null | false |
Std.DHashMap.Internal.toListModel_replicate_nil | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {c : ℕ},
Std.DHashMap.Internal.toListModel (Array.replicate c Std.DHashMap.Internal.AssocList.nil) = [] | null | true |
Lean.Lsp.instFromJsonTextDocumentContentChangeEvent | Lean.Data.Lsp.TextSync | Lean.FromJson Lean.Lsp.TextDocumentContentChangeEvent | null | true |
HomogeneousIdeal.toIdeal_inf | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜]
(I J : HomogeneousIdeal 𝒜), (I ⊓ J).toIdeal = I.toIdeal ⊓ J.toIdeal | null | true |
SSet.Subcomplex.unionProd.pushoutObjObj_ι | Mathlib.AlgebraicTopology.SimplicialSet.PushoutProduct | ∀ {X Y : SSet} (S : X.Subcomplex) (T : Y.Subcomplex),
(SSet.Subcomplex.unionProd.pushoutObjObj S T).ι = (S.unionProd T).ι | null | true |
isLUB_singleton._simp_2 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, IsLUB {a} a = True | null | false |
Int.getElem?_toArray_rcc_eq_some_iff | Init.Data.Range.Polymorphic.IntLemmas | ∀ {k m n : ℤ} {i : ℕ}, (m...=n).toArray[i]? = some k ↔ i < (n + 1 - m).toNat ∧ m + ↑i = k | null | true |
SchwartzMap.integralCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {D : Type u_1} [inst : NormedAddCommGroup D] (n : ℕ) (x : D), 0 < (1 + ‖x‖) ^ ↑n | null | false |
HasStrictFDerivAt.const_cpow | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {f' : StrongDual ℂ E} {x : E}
{c : ℂ},
HasStrictFDerivAt f f' x → c ≠ 0 ∨ f x ≠ 0 → HasStrictFDerivAt (fun x => c ^ f x) ((c ^ f x * Complex.log c) • f') x | null | true |
Valuation.Integers.one_of_isUnit | Mathlib.RingTheory.Valuation.Integers | ∀ {R : Type u} {Γ₀ : Type v} [inst : CommRing R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation R Γ₀}
{O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O R],
v.Integers O → ∀ {x : O}, IsUnit x → v ((algebraMap O R) x) = 1 | null | true |
CategoryTheory.Abelian.LeftResolution.chainComplexXIso | Mathlib.Algebra.Homology.LeftResolution.Basic | {A : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] →
{ι : CategoryTheory.Functor C A} →
(Λ : CategoryTheory.Abelian.LeftResolution ι) →
(X : A) →
[inst_2 : ι.Full] →
[in... | The isomorphism which gives the inductive step of the construction of `Λ.chainComplex X`. | true |
RBTree.RBNode.Path.listL._f | BatteriesRecycling.RBTree.Lemmas | {α : Type u_1} → (x : RBTree.RBNode.Path α) → RBTree.RBNode.Path.below x → List α | null | false |
_private.Mathlib.Data.Vector3.0.Fin2.add.match_1.eq_1 | Mathlib.Data.Vector3 | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
(match 0 with
| 0 => h_1 ()
| k.succ => h_2 k) =
h_1 () | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctorCore.map | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
(self : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) → {X Y : B} → (X ⟶ Y) → (self.obj X ⟶ self.obj Y) | action on 1-morphisms | true |
CategoryTheory.Localization.Preadditive.add | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[CategoryTheory.Preadditive C] →
{L : CategoryTheory.Functor C D} →
(W : CategoryTheory.MorphismProperty C) →
[L.IsLocalization W] →... | The addition of morphisms in `D`, when `L : C ⥤ D` is a localization
functor, `C` is preadditive and there is a left calculus of fractions. | true |
SimpleGraph.induceHom_injective | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {G' : SimpleGraph W} {s : Set V} {t : Set W} (φ : G →g G')
(φst : Set.MapsTo (⇑φ) s t), Set.InjOn (⇑φ) s → Function.Injective ⇑(SimpleGraph.induceHom φ φst) | null | true |
Std.HashMap.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α Unit} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m → List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (m.insertManyIfNewUnit l).getKey! k' = k | null | true |
RBTree.RBNode.size_lt_depth | BatteriesRecycling.RBTree.Depth | ∀ {α : Type u_1} (t : RBTree.RBNode α), t.size < 2 ^ t.depth | null | true |
Lean.StructureResolutionOrderResult.mk.noConfusion | Lean.Structure | {P : Sort u} →
{resolutionOrder : Array Lean.Name} →
{conflicts : Array Lean.StructureResolutionOrderConflict} →
{resolutionOrder' : Array Lean.Name} →
{conflicts' : Array Lean.StructureResolutionOrderConflict} →
{ resolutionOrder := resolutionOrder, conflicts := conflicts } =
... | null | false |
_private.Mathlib.Probability.Independence.ZeroOne.0.ProbabilityTheory.Kernel.indep_limsup_atTop_self._simp_1_2 | Mathlib.Probability.Independence.ZeroOne | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
Monoid.CoprodI.NeWord.last.eq_def | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (x x_1 : ι) (x_2 : Monoid.CoprodI.NeWord M x x_1),
x_2.last =
match x, x_1, x_2 with
| x, .(x), Monoid.CoprodI.NeWord.singleton x_3 _hne1 => x_3
| x, x_3, _w₁.append _hne w₂ => w₂.last | null | true |
Finset.disjoint_val._simp_1 | Mathlib.Data.Finset.Disjoint | ∀ {α : Type u_2} {s t : Finset α}, Disjoint s.val t.val = Disjoint s t | null | false |
MeasureTheory.mem_fundamentalFrontier._simp_2 | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] {s : Set α} {x : α},
(x ∈ MeasureTheory.fundamentalFrontier G s) = (x ∈ s ∧ ∃ g, g ≠ 1 ∧ x ∈ g • s) | null | false |
RootPairing.CorootForm | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] → RootPairing ι R M N → [Fintype ι] → LinearMap.BilinFor... | An invariant inner product on the coweight space. | true |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.comap_isBasis_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
Std.TreeSet.Raw.size_insertMany_list_le | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {l : List α}, (t.insertMany l).size ≤ t.size + l.length | null | true |
Lean.Expr.hasNonSyntheticSorry | Lean.Util.Sorry | Lean.Expr → Bool | null | true |
CategoryTheory.ThinSkeleton.map₂Functor._proof_2 | Mathlib.CategoryTheory.Skeletal | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_4, u_3} E]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (x : CategoryTheory.ThinSkeleton C)
{X Y Z : CategoryTheory.ThinS... | null | false |
Vector.append_empty | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n}, xs ++ #v[] = xs | null | true |
TopCat.binaryCofan._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ (X Y : TopCat), Continuous Sum.inr | null | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Solvers.mergeTerms.go.match_3._arg_pusher | Lean.Meta.Tactic.Grind.Types | ∀ (motive : Lean.Meta.Grind.SolverTerms → Lean.Meta.Grind.SolverTerms → Sort u_1) (α : Sort u✝) (β : α → Sort v✝)
(f : (x : α) → β x) (rel : Lean.Meta.Grind.SolverTerms → Lean.Meta.Grind.SolverTerms → α → Prop)
(rhsTerms lhsTerms : Lean.Meta.Grind.SolverTerms)
(h_1 :
Unit →
((y : α) → rel Lean.Meta.Grin... | null | false |
CategoryTheory.Join.instUniqueHomLeftRight | Mathlib.CategoryTheory.Join.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{X : C} → {Y : D} → Unique (CategoryTheory.Join.left X ⟶ CategoryTheory.Join.right Y) | null | true |
Mathlib.Tactic.Bicategory.instMonadMor₂BicategoryM | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | Mathlib.Tactic.BicategoryLike.MonadMor₂ Mathlib.Tactic.Bicategory.BicategoryM | null | true |
MemHolder.nsmul | Mathlib.Topology.MetricSpace.HolderNorm | ∀ {X : Type u_1} {Y : Type u_2} [inst : MetricSpace X] [inst_1 : NormedAddCommGroup Y] {r : NNReal} {f : X → Y}
[NormedSpace ℝ Y] (n : ℕ), MemHolder r f → MemHolder r (n • f) | null | true |
instRingCliffordAlgebra._proof_3 | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) (a b c : CliffordAlgebra Q), a + b + c = a + (b + c) | null | false |
mdifferentiableOn_iUnion_iff_of_isOpen | Mathlib.Geometry.Manifold.MFDeriv.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] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | A function is differentiable on a union of open sets `s i`
iff it is differentiable on each `s i`. | true |
Asymptotics.isEquivalent_iff_tendsto_one | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedField β] {u v : α → β} {l : Filter α},
(∀ᶠ (x : α) in l, v x ≠ 0) → (Asymptotics.IsEquivalent l u v ↔ Filter.Tendsto (u / v) l (nhds 1)) | null | true |
Fin.val_sub_one_of_ne_zero | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {i : Fin n}, i ≠ 0 → ↑(i - 1) = ↑i - 1 | null | true |
USize.ofNatTruncate_eq_ofNat | Init.Data.UInt.Lemmas | ∀ n < USize.size, USize.ofNatClamp n = USize.ofNat n | null | true |
_private.Mathlib.Data.Set.Pointwise.Support.0.support_comp_inv_smul._simp_1_2 | Mathlib.Data.Set.Pointwise.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {x : ι}, (x ∈ Function.support f) = (f x ≠ 0) | null | false |
_private.Mathlib.Data.EReal.Basic.0.EReal.exists_rat_btwn_of_lt.match_1_3 | Mathlib.Data.EReal.Basic | ∀ (a : ℝ) (motive : (∃ q, ↑q < a) → Prop) (x : ∃ q, ↑q < a), (∀ (b : ℚ) (hab : ↑b < a), motive ⋯) → motive x | null | false |
CategoryTheory.Limits.IsLimit.liftConeMorphism | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cone F} →
CategoryTheory.Limits.IsLimit t → (s : CategoryTheory.Limits.Cone F) → s ⟶ t | The universal morphism from any other cone to a limit cone. | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Concrete.0.Equiv.Perm.isoCycle._simp_6 | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ ↑l) = (a ∈ l) | null | false |
Equiv.sumIsRight_apply | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_1} {β : Type u_2} (x : { x // x.isRight = true }), Equiv.sumIsRight x = (↑x).getRight ⋯ | null | true |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_10 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α} (hl : l ≠ []), ¬[l.getLast ⋯].isEmpty = true → [l.getLast ⋯] ≠ [] | null | false |
CategoryTheory.Limits.pushoutPushoutRightIsPushout._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X₁ X₂ X₃ Z₁ Z₂ : C} (g₁ : Z₁ ⟶ X₁) (g₂ : Z₁ ⟶ X₂)
(g₃ : Z₂ ⟶ X₂) (g₄ : Z₂ ⟶ X₃) [inst_1 : CategoryTheory.Limits.HasPushout g₁ g₂]
[inst_2 : CategoryTheory.Limits.HasPushout g₃ g₄]
[inst_3 :
CategoryTheory.Limits.HasPushout g₁
(CategoryTheor... | null | false |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Markov.0.MeasureTheory.ae_lt_top'._simp_1_1 | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {p : α → Prop}, (∀ᵐ (a : α) ∂μ, p a) = (μ {a | ¬p a} = 0) | null | false |
UniqueAdd.of_image_filter | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] [inst_2 : DecidableEq H] (f : G →ₙ+ H) {A B : Finset G}
{aG bG : G} {aH bH : H},
f aG = aH →
f bG = bH →
UniqueAdd (Finset.image (⇑f) A) (Finset.image (⇑f) B) aH bH →
UniqueAdd ({a ∈ A | f a = aH}) ({b ∈ B | f b = bH}) aG bG → UniqueA... | null | true |
CliffordAlgebra.reverse_involutive._simp_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M}, Function.Involutive ⇑CliffordAlgebra.reverse = True | null | false |
OpenPartialHomeomorph.trans' | Mathlib.Topology.OpenPartialHomeomorph.Composition | {X : Type u_1} →
{Y : Type u_3} →
{Z : Type u_5} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
[inst_2 : TopologicalSpace Z] →
(e : OpenPartialHomeomorph X Y) →
(e' : OpenPartialHomeomorph Y Z) → e.target = e'.source → OpenPartialHomeomorph X Z | Composition of two open partial homeomorphisms when the target of the first and the source of
the second coincide. | true |
IsGroupLikeElem.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.GroupLike | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A] {a : A},
CoalgebraStruct.counit a = 1 → CoalgebraStruct.comul a = a ⊗ₜ[R] a → IsGroupLikeElem R a | null | false |
_private.Mathlib.Topology.Algebra.Order.Field.0.tendsto_const_mul_pow_nhds_iff'._simp_1_1 | Mathlib.Topology.Algebra.Order.Field | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [T1Space X] {l : Filter Y} [l.NeBot] {c d : X},
Filter.Tendsto (fun x => c) l (nhds d) = (c = d) | null | false |
OrderAddMonoidHom.coe_zero | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : AddZeroClass α]
[inst_3 : AddZeroClass β], ⇑0 = 0 | null | true |
Lean.Parser.numLitFn | Lean.Parser.Basic | Lean.Parser.ParserFn | null | true |
StarAlgebra.elemental.characterSpaceToSpectrum._proof_4 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ∀ {A : Type u_1} [inst : CStarAlgebra A], SubringClass (StarSubalgebra ℂ A) A | null | false |
Algebra.normalizedTrace_algebraMap_apply | Mathlib.FieldTheory.NormalizedTrace | ∀ (F : Type u_3) (E : Type u_4) (K : Type u_5) [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra E K] [inst_5 : Algebra F K] [IsScalarTower F E K]
[inst_7 : Algebra.IsIntegral F E] [inst_8 : Algebra.IsIntegral F K] [inst_9 : CharZero F] (a : E),
(Algebra.normalizedTra... | null | true |
sup_left_right_swap | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α] (a b c : α), a ⊔ b ⊔ c = c ⊔ b ⊔ a | null | true |
pythagoreanTriple_comm | Mathlib.NumberTheory.PythagoreanTriples | ∀ {x y z : ℤ}, PythagoreanTriple x y z ↔ PythagoreanTriple y x z | Pythagorean triples are interchangeable, i.e `x * x + y * y = y * y + x * x = z * z`.
This comes from additive commutativity. | true |
AlgebraicGeometry.IsOpenImmersion.ΓIsoTop._proof_1 | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.IsOpenImmersion f],
AlgebraicGeometry.Scheme.Hom.opensRange f = (AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj ⊤ | null | false |
RingHom.fromOpposite._proof_3 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S),
(↑(f.toAddMonoidHom.comp MulOpposite.opAddEquiv.symm.toAddMonoidHom)).toFun 0 = 0 | null | false |
Asymptotics.isTheta_of_div_tendsto_nhds_ne_zero | Mathlib.Analysis.Asymptotics.Theta | ∀ {α : Type u_1} {𝕜 : Type u_14} [inst : NormedField 𝕜] {l : Filter α} {c : 𝕜} {f g : α → 𝕜},
Filter.Tendsto (fun x => g x / f x) l (nhds c) → c ≠ 0 → f =Θ[l] g | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_rotateLeft_of_lt._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {r n : ℕ} (w : ℕ), r < w + 1 → n < w + 1 - r → ¬n < w + 1 → False | null | false |
CategoryTheory.MorphismProperty.IsLocalAtSource.rec | Mathlib.CategoryTheory.MorphismProperty.Local | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{P : CategoryTheory.MorphismProperty C} →
{K : CategoryTheory.Precoverage C} →
{motive : P.IsLocalAtSource K → Sort u_1} →
([toRespects : P.Respects (CategoryTheory.MorphismProperty.isomorphisms C)] →
(comp :
... | null | false |
BoxIntegral.Box.mk' | Mathlib.Analysis.BoxIntegral.Box.Basic | {ι : Type u_1} → (ι → ℝ) → (ι → ℝ) → WithBot (BoxIntegral.Box ι) | Make a `WithBot (Box ι)` from a pair of corners `l u : ι → ℝ`. If `l i < u i` for all `i`,
then the result is `⟨l, u, _⟩ : Box ι`, otherwise it is `⊥`. In any case, the result interpreted
as a set in `ι → ℝ` is the set `{x : ι → ℝ | ∀ i, x i ∈ Ioc (l i) (u i)}`. | true |
Nat.divMaxPow_one_left | Mathlib.Data.Nat.MaxPowDiv | ∀ (p : ℕ), Nat.divMaxPow 1 p = 1 | null | true |
AddAction.instElemOrbit_1 | Mathlib.GroupTheory.GroupAction.Defs | {G : Type u_1} →
{α : Type u_2} →
[inst : AddGroup G] → [inst_1 : AddAction G α] → (x : AddAction.orbitRel.Quotient G α) → AddAction G ↑x.orbit | null | true |
Qq.Impl.ExprBackSubstResult.quoted.injEq | Qq.Macro | ∀ (e e_1 : Lean.Expr), (Qq.Impl.ExprBackSubstResult.quoted e = Qq.Impl.ExprBackSubstResult.quoted e_1) = (e = e_1) | null | true |
CategoryTheory.Functor.LaxMonoidal.right_unitality | 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) [self : F.LaxMonoidal] (X : C),
(CategoryTheory.MonoidalCategoryStruct.... | null | true |
CategoryTheory.Limits.MulticospanIndex.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : SizeOf C] (left : J.L → C) (right : J.R → C) (fst : (b : J.R) → left (J.fst b) ⟶ right b)
(snd : (b : J.R) → left (J.snd b) ⟶ right b), sizeOf { left := left, right := right, fst := fst, snd := snd } = 1 | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.logb_prod._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : CommMonoidWithZero M₀] {f : ι → M₀} {s : Finset ι} [Nontrivial M₀]
[NoZeroDivisors M₀], (∏ x ∈ s, f x ≠ 0) = ∀ a ∈ s, f a ≠ 0 | null | false |
CategoryTheory.FreeMonoidalCategory.Hom.ρ_hom.elim | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} →
{motive : (a a_1 : CategoryTheory.FreeMonoidalCategory C) → a.Hom a_1 → Sort u_1} →
{a a_1 : CategoryTheory.FreeMonoidalCategory C} →
(t : a.Hom a_1) →
t.ctorIdx = 5 →
((X : CategoryTheory.FreeMonoidalCategory C) →
motive (X.tensor CategoryTheory.FreeMonoidalCa... | null | false |
CategoryTheory.SimplicialObject.δ₀Iter.eq_1 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (X : CategoryTheory.SimplicialObject C) {n m : ℕ} (i : ℕ)
(hi : n + i = m), X.δ₀Iter i hi = X.map (SimplexCategory.δ₀Iter i hi).op | null | true |
UpperHalfPlane.dist_triangle | Mathlib.Analysis.Complex.UpperHalfPlane.Metric | ∀ (a b c : UpperHalfPlane), dist a c ≤ dist a b + dist b c | null | true |
SnakeLemma.δ._proof_2 | Mathlib.Algebra.Module.SnakeLemma | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
AddSubgroup.neg_mem' | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_3} [inst : AddGroup G] (self : AddSubgroup G) {x : G}, x ∈ self.carrier → -x ∈ self.carrier | `G` is closed under negation | true |
Submonoid.noConfusion | Mathlib.Algebra.Group.Submonoid.Defs | {P : Sort u} →
{M : Type u_3} →
{inst : MulOneClass M} →
{t : Submonoid M} →
{M' : Type u_3} →
{inst' : MulOneClass M'} →
{t' : Submonoid M'} → M = M' → inst ≍ inst' → t ≍ t' → Submonoid.noConfusionType P t t' | null | false |
CategoryTheory.map_coyonedaEquiv | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {F : CategoryTheory.Functor C (Type v₁)}
(f : CategoryTheory.coyoneda.obj (Opposite.op X) ⟶ F) (g : X ⟶ Y),
(CategoryTheory.ConcreteCategory.hom (F.map g)) (CategoryTheory.coyonedaEquiv f) =
(CategoryTheory.ConcreteCategory.hom (f.app Y)) g | null | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_17 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = a ^ (m * n) | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.simplifyResultingUniverse.simp.match_3 | Lean.Elab.MutualInductive | (motive : Lean.Level → Sort u_1) →
(u : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((a : Lean.LMVarId) → motive (Lean.Level.mvar a)) →
((a : Lean.Name) → motive (Lean.Level.param a)) →
((a : Lean.Level) → motive a.succ) →
((a b : Lean.Level) → motive (a.max b)) → ((a b : L... | null | false |
DirichletCharacter.FactorsThrough.χ₀._proof_2 | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n} {d : ℕ} (h : χ.FactorsThrough d),
∃ χ₀, χ = (DirichletCharacter.changeLevel ⋯) χ₀ | null | false |
WithBot.pred_coe | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] [inst_2 : (a : α) → Decidable (Order.pred a = a)]
[NoMinOrder α] {a : α}, Order.pred ↑a = ↑(Order.pred a) | null | true |
CategoryTheory.Functor.LaxMonoidal.prod'._aux_1 | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u_6} →
[inst : CategoryTheory.Category.{u_5, u_6} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u_3} →
[inst_2 : CategoryTheory.Category.{u_1, u_3} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{E : Type u_4} →
[inst_4 : CategoryThe... | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Pred.0.String.apply_of_skipSuffixWhile_le_prop._simp_1_2 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {s : String} {p q : s.Pos}, (p.toSlice < q.toSlice) = (p < q) | null | false |
_private.Mathlib.Combinatorics.Pigeonhole.0.Fintype.exists_card_fiber_lt_of_card_lt_nsmul.match_1_1 | Mathlib.Combinatorics.Pigeonhole | ∀ {α : Type u_3} {β : Type u_1} {M : Type u_2} [inst : DecidableEq β] [inst_1 : Fintype α] [inst_2 : Fintype β]
(f : α → β) {b : M} [inst_3 : CommSemiring M] [inst_4 : LinearOrder M]
(motive : (∃ y ∈ Finset.univ, ↑{x | f x = y}.card < b) → Prop) (x : ∃ y ∈ Finset.univ, ↑{x | f x = y}.card < b),
(∀ (y : β) (left :... | null | false |
ProperCone.relative_hyperplane_separation | Mathlib.Analysis.Convex.Cone.InnerDual | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E]
[inst_2 : CompleteSpace E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace ℝ F] [inst_5 : CompleteSpace F]
{C : ProperCone ℝ E} {f : E →L[ℝ] F} {b : F},
b ∈ ProperCone.map f C ↔ ∀ (y : F), (ContinuousLinearM... | Relative geometric interpretation of **Farkas' lemma**. Also stronger version of the
**Hahn-Banach separation theorem** for proper cones. | true |
MeasureTheory.average_const | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[CompleteSpace E] (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ] [h : NeZero μ] (c : E),
⨍ (_x : α), c ∂μ = c | null | true |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.Ico_image_const_sub_eq_Ico._simp_1_2 | Mathlib.Order.Interval.Finset.Nat | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Ico a b) = (a ≤ x ∧ x < b) | null | false |
Nat.card_ulift | Mathlib.SetTheory.Cardinal.Finite | ∀ (α : Type u_3), Nat.card (ULift.{u_4, u_3} α) = Nat.card α | null | true |
iteratedFDerivWithin._proof_1 | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], IsTopologicalAddGroup F | null | false |
Lean.TheoremVal.all._default | Lean.Declaration | Lean.Name → List Lean.Name | null | false |
Batteries.UnionFind.link | Batteries.Data.UnionFind.Basic | (self : Batteries.UnionFind) → Fin self.size → (y : Fin self.size) → self.parent ↑y = ↑y → Batteries.UnionFind | Link a union-find node to a root node. | true |
CategoryTheory.Iso.self_symm_conj | Mathlib.CategoryTheory.Conj | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y) (f : CategoryTheory.End Y),
α.conj (α.symm.conj f) = f | null | true |
_private.Mathlib.Analysis.Complex.Poisson.0.le_re_herglotzRieszKernel_aux._simp_1_4 | Mathlib.Analysis.Complex.Poisson | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.