name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.Array.Lemmas.0.Array.back_append_right._proof_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α}, 0 < ys.size → ¬0 < xs.size + ys.size → False | null | false |
Lean.Widget.WidgetSource.rec | Lean.Widget.UserWidget | {motive : Lean.Widget.WidgetSource → Sort u} →
((sourcetext : String) → motive { sourcetext := sourcetext }) → (t : Lean.Widget.WidgetSource) → motive t | null | false |
MeasureTheory.LocallyIntegrable.exists_nat_integrableOn | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ : MeasureTheory.Measure X} [SecondCountableTopology X],
MeasureTheory.LocallyIntegrable f μ →
∃ u, (∀ (n : ℕ), IsOpen (u n)) ∧ ⋃ n, u n = Set.univ ∧ ... | If a function is locally integrable in a second countable topological space,
then there exists a sequence of open sets covering the space on which it is integrable. | true |
ComplexShape.χ | Mathlib.Algebra.Homology.EulerCharacteristic | {ι : Type u_1} → (c : ComplexShape ι) → [c.EulerCharSigns] → ι → ℤˣ | The sign at index `i` for Euler characteristic computations. | true |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.BadChar.rec | Mathlib.NumberTheory.LSeries.Nonvanishing | {N : ℕ} →
[inst : NeZero N] →
{motive : DirichletCharacter.BadChar✝ N → Sort u} →
((χ : DirichletCharacter ℂ N) →
(χ_ne : χ ≠ 1) →
(χ_sq : χ ^ 2 = 1) →
(hχ : DirichletCharacter.LFunction χ 1 = 0) → motive { χ := χ, χ_ne := χ_ne, χ_sq := χ_sq, hχ := hχ }) →
(t : Di... | null | false |
SimpleGraph.Connected.rec | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | {V : Type u} →
{G : SimpleGraph V} →
{motive : G.Connected → Sort u_1} →
((preconnected : G.Preconnected) → [nonempty : Nonempty V] → motive ⋯) → (t : G.Connected) → motive t | null | false |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.Solve.0.Lean.Elab.Tactic.Do.Internal.VCGen.replaceProgDefEq | Lean.Elab.Tactic.Do.Internal.VCGen.Solve | Lean.MVarId →
Lean.Expr →
Lean.Expr →
Lean.Expr →
Lean.Expr →
Array Lean.Expr →
Lean.Expr →
Lean.Expr →
Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Elab.Tactic.Do.Internal.VCGenM Lean.MVarId | Replace the program in `goal`'s target with `e'` (which must be definitionally equal). | true |
Functor.supp.eq_1 | Mathlib.Data.PFunctor.Univariate.Basic | ∀ {F : Type u → Type v} [inst : Functor F] {α : Type u} (x : F α),
Functor.supp x = {y | ∀ ⦃p : α → Prop⦄, Functor.Liftp p x → p y} | null | true |
PositiveLinearMap.preGNS_norm_def | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] (f : A →ₚ[ℂ] ℂ) [inst_2 : StarOrderedRing A]
(a : f.PreGNS), ‖a‖ = √(f (star (f.ofPreGNS a) * f.ofPreGNS a)).re | null | true |
ContinuousLinearMapWOT.comp.congr_simp | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_5} {𝕜₂ : Type u_6} {𝕜₃ : Type u_7} {E : Type u_9} {F : Type u_10} {G : Type u_11} [inst : NormedField 𝕜₁]
[inst_1 : NormedField 𝕜₂] [inst_2 : NormedField 𝕜₃] {σ₁₂ : 𝕜₁ →+* 𝕜₂} {σ₁₃ : 𝕜₁ →+* 𝕜₃} {σ₂₃ : 𝕜₂ →+* 𝕜₃}
[inst_3 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [inst_4 : AddCommGroup E] [inst_5 : ... | null | true |
Subgroup.Normal.conj_smul_eq_self | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : Group G] (g : G) (H : Subgroup G) [h : H.Normal], MulAut.conj g • H = H | null | true |
_private.Init.Data.Nat.SOM.0.Nat.SOM.Mon.mul.go.match_1.eq_2 | Init.Data.Nat.SOM | ∀ (motive : Nat.SOM.Mon → Nat.SOM.Mon → Sort u_1) (m₂ : Nat.SOM.Mon) (h_1 : (m₁ : Nat.SOM.Mon) → motive m₁ [])
(h_2 : (m₂ : Nat.SOM.Mon) → motive [] m₂)
(h_3 :
(v₁ : Nat.Linear.Var) →
(m₁ : List Nat.Linear.Var) → (v₂ : Nat.Linear.Var) → (m₂ : List Nat.Linear.Var) → motive (v₁ :: m₁) (v₂ :: m₂)),
(m₂ = [... | null | true |
AlgebraicGeometry.specTargetImageFactorization._proof_1 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {A : CommRingCat} (f : X ⟶ AlgebraicGeometry.Spec A),
AlgebraicGeometry.specTargetImageIdeal f ≤ AlgebraicGeometry.specTargetImageIdeal f | null | false |
CategoryTheory.Limits.colimitHomIsoLimitYoneda_inv_comp_π_assoc | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [inst_1 : CategoryTheory.Category.{v₂, v₁} I]
(F : CategoryTheory.Functor I C) [inst_2 : CategoryTheory.Limits.HasColimit F]
[inst_3 : CategoryTheory.Limits.HasLimitsOfShape Iᵒᵖ (Type u₂)] (A : C) (i : I) {Z : Type u₂} (h : (F.obj i ⟶ A) ⟶ Z)... | null | true |
_private.Batteries.Lean.Meta.UnusedNames.0.Lean.LocalContext.getUnusedUserNames.loop.match_1 | Batteries.Lean.Meta.UnusedNames | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n | null | false |
CategoryTheory.Limits.Cocone.category._proof_10 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] {F : CategoryTheory.Functor J C}
{W X Y Z : CategoryTheory.Limits.Cocone F} (f : CategoryTheory.Limits.CoconeMorphism X W)
(g : CategoryTheory.Limits.CoconeMorphism Y X) (h : CategoryTheor... | null | false |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.tendsto_nhds_top_iff_real._simp_1_1 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) | null | false |
Real.sinOrderIso._proof_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | Real.sin '' Set.Icc (-(Real.pi / 2)) (Real.pi / 2) = Set.Icc (-1) 1 | null | false |
UInt8.not_le | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, ¬a ≤ b ↔ b < a | null | true |
_private.Mathlib.Geometry.Euclidean.Similarity.0.EuclideanGeometry.similar_of_side_angle_side._proof_1_2 | Mathlib.Geometry.Euclidean.Similarity | ∀ {P₁ : Type u_1} {P₂ : Type u_2} [inst : MetricSpace P₁] [inst_1 : MetricSpace P₂] {a b c : P₁} {a' b' c' : P₂},
dist a' b' ≠ 0 → dist a b / dist a' b' = dist b c / dist b' c' → dist a b = dist a b / dist a' b' * dist a' b' | null | false |
Std.BundledIterM.Equiv._proof_1 | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ (m : Type u_1 → Type u_2) (β : Type u_1) [inst : Monad m] [inst_1 : LawfulMonad m]
(R S : Std.BundledIterM m β → Std.BundledIterM m β → Prop),
Lean.Order.PartialOrder.rel R S →
∀ (ita itb : Std.BundledIterM m β),
Std.Iterators.HetT.map (Std.IterStep.mapIterator (Quot.mk S)) ita.step =
Std.Iter... | null | false |
instCountablePLift | Mathlib.Data.Countable.Defs | ∀ {α : Sort u} [Countable α], Countable (PLift α) | null | true |
RestrictedProduct.mk.congr_simp | Mathlib.Topology.Algebra.RestrictedProduct.Units | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)} {𝓕 : Filter ι} (x x_1 : (i : ι) → R i) (e_x : x = x_1)
(hx : ∀ᶠ (i : ι) in 𝓕, x i ∈ A i), RestrictedProduct.mk x hx = RestrictedProduct.mk x_1 ⋯ | null | true |
Matrix.toMatrix₂Aux_toLinearMap₂'Aux | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ (R : Type u_1) {R₁ : Type u_2} {S₁ : Type u_3} {R₂ : Type u_4} {S₂ : Type u_5} {N₂ : Type u_10} {n : Type u_11}
{m : Type u_12} [inst : CommSemiring R] [inst_1 : Semiring R₁] [inst_2 : Semiring S₁] [inst_3 : Semiring R₂]
[inst_4 : Semiring S₂] [inst_5 : AddCommMonoid N₂] [inst_6 : Module R N₂] [inst_7 : Module S₁... | null | true |
LowerSet.prod_self_lt_prod_self._simp_1 | Mathlib.Order.UpperLower.Prod | ∀ {α : Type u_1} [inst : Preorder α] {s₁ s₂ : LowerSet α}, (s₁ ×ˢ s₁ < s₂ ×ˢ s₂) = (s₁ < s₂) | null | false |
generatePiSystem_subset_self | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} {S : Set (Set α)}, IsPiSystem S → generatePiSystem S ⊆ S | null | true |
Lean.Meta.Grind.Methods.evalTactic | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Methods → Lean.Meta.Grind.EvalTactic | null | true |
Mathlib.Linter.linter.style.longLine | Mathlib.Tactic.Linter.Style | Lean.Option Bool | The "longLine" linter emits a warning on lines longer than
`linter.style.longLine.maxLineLength` (which defaults to 100) characters.
We allow lines containing URLs to be longer, though. | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_3 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ}, ∀ k ≤ n, ¬k + 1 ≤ n + 3 → False | null | false |
_private.Mathlib.Analysis.Distribution.TestFunction.0.TestFunction.instIsTopologicalAddGroup.match_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (x : TopologicalSpace (TestFunction Ω F n))
(motive :
x ∈
{t |
TestFunction.originalTop Ω F n ≤ t ∧
... | null | false |
ProbabilityTheory.Kernel.iIndepFun.comp | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8} {γ : ι → Type u_9}
{mβ : (i : ι) → MeasurableSpace (β i)} {mγ : (i : ι) → MeasurableSpace (γ i)} {f : (i : ι) → Ω → β i},
Probability... | null | true |
Algebra.exists_aeval_invOf_eq_zero_of_idealMap_adjoin_sup_span_eq_top | Mathlib.RingTheory.Polynomial.Ideal | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (x : S) (I : Ideal R),
I ≠ ⊤ →
∀ [inst_3 : Invertible x],
Ideal.map (algebraMap R ↥R[x]) I ⊔ Ideal.span {⟨x, ⋯⟩} = ⊤ →
∃ p, p.leadingCoeff - 1 ∈ I ∧ (Polynomial.aeval ⅟x) p = 0 | null | true |
CategoryTheory.Limits.isTerminalEquivUnique._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete PEmpty.{1}) C) (Y : C) (u : (X : C) → Unique (X ⟶ Y))
(s : CategoryTheory.Limits.Cone F) (j : CategoryTheory.Discrete PEmpty.{1}),
CategoryTheory.CategoryStruct.comp default
({ pt := Y,
... | null | false |
PFunctor.Approx.sCorec._unsafe_rec | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → {X : Type w} → (X → ↑F X) → X → (n : ℕ) → PFunctor.Approx.CofixA F n | null | false |
ULift.semiring._proof_9 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : Semiring R] (a b c : ULift.{u_1, u_2} R), (a + b) * c = a * c + b * c | null | false |
OrderedFinpartition.extendLeft._proof_14 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition n) (i : Fin c.length), 0 < Fin.cons 1 c.partSize i.succ | null | false |
_private.Lean.Parser.Level.0.Lean.Parser.Level.hole._regBuiltin.Lean.Parser.Level.hole.declRange_3 | Lean.Parser.Level | IO Unit | null | false |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.RxoIterator.step_cons_of_isLT | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {t : Std.DTreeMap.Internal.Impl α β}
{it : Std.DTreeMap.Internal.Zipper α β} [inst : Ord α] {upper : α} {h : (compare k upper).isLT = true},
{ iter := Std.DTreeMap.Internal.Zipper.cons k v t it, upper := upper }.step =
Std.IterStep.yield { internalState := { ite... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.EdgeDisjointTriangles.card_edgeFinset_le._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
Lean.Meta.Match.Overlaps.noConfusionType | Lean.Meta.Match.MatcherInfo | Sort u → Lean.Meta.Match.Overlaps → Lean.Meta.Match.Overlaps → Sort u | null | false |
Finset.finsuppAntidiag_insert.match_3 | Mathlib.Algebra.Order.Antidiag.Finsupp | ∀ {ι : Type u_1} {μ : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ] [inst_2 : Finset.HasAntidiagonal μ]
[inst_3 : DecidableEq μ] {a : ι} {s : Finset ι} (p : μ × μ) (x : ↥(s.finsuppAntidiag p.2))
(motive : (x_1 : ↥(s.finsuppAntidiag p.2)) → (fun f => (↑f).update a p.1) x_1 = (fun f => (↑f).update a p.1... | null | false |
neg_lt_sub_iff_lt_add | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] [AddRightStrictMono α] {a b c : α},
-a < b - c ↔ c < a + b | null | true |
Finsupp.basisSingleOne | Mathlib.LinearAlgebra.Finsupp.VectorSpace | {R : Type u_1} → {ι : Type u_3} → [inst : Semiring R] → Module.Basis ι R (ι →₀ R) | The basis on `ι →₀ R` with basis vectors `fun i ↦ single i 1`. | true |
Aesop.Frontend.Priority.int.elim | Aesop.Frontend.RuleExpr | {motive : Aesop.Frontend.Priority → Sort u} →
(t : Aesop.Frontend.Priority) → t.ctorIdx = 0 → ((i : ℤ) → motive (Aesop.Frontend.Priority.int i)) → motive t | null | false |
BoundedContinuousFunction.instModule'._proof_8 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} {β : Type u_2} {𝕜 : Type u_3} [inst : NormedField 𝕜] [inst_1 : TopologicalSpace α]
[inst_2 : SeminormedAddCommGroup β] [inst_3 : NormedSpace 𝕜 β] (f : BoundedContinuousFunction α β), 1 • f = f | null | false |
CategoryTheory.Triangulated.Octahedron.map_m₁ | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {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] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] [inst_4 : CategoryTheory.Limits.HasZeroObject C]
[inst_5 : CategoryTheory.Limits.HasZeroObject D] [inst_6 : Ca... | null | true |
Lean.Elab.mkMessageCore | Lean.Elab.Exception | String → Lean.FileMap → Lean.MessageData → Lean.MessageSeverity → String.Pos.Raw → String.Pos.Raw → Lean.Message | null | true |
Int.decidableLELT._proof_3 | Mathlib.Data.Int.Range | ∀ (P : ℤ → Prop) (m n : ℤ), (∀ r ∈ m.range n, P r) ↔ ∀ (r : ℤ), m ≤ r → r < n → P r | null | false |
TopCommRingCat.instConcreteCategorySubtypeRingHomαContinuousCoe._proof_3 | Mathlib.Topology.Category.TopCommRingCat | ∀ {X : TopCommRingCat} (x : X.α), (CategoryTheory.CategoryStruct.id X) x = x | null | false |
CharacterModule.instModule._proof_5 | Mathlib.Algebra.Module.CharacterModule | ∀ (R : Type u_2) [inst : CommRing R] (A : Type u_1) [inst_1 : AddCommGroup A] [inst_2 : Module R A] (r s : R)
(x : CharacterModule A), (r + s) • x = r • x + s • x | null | false |
Lean.Elab.Do.withDeadCode | Lean.Elab.Do.Basic | {α : Type} → Lean.Elab.Do.CodeLiveness → Lean.Elab.Do.DoElabM α → Lean.Elab.Do.DoElabM α | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic.0.CategoryTheory.IsPullback.of_iso'._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : Z ⟶ Y} {g : Z ⟶ X},
(CategoryTheory.CategoryStruct.comp f α.inv = g) = (f = CategoryTheory.CategoryStruct.comp g α.hom) | null | false |
CategoryTheory.ShortComplex.instMonoICycles | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasLeftHomology], CategoryTheory.Mono S.iCycles | null | true |
IsPurelyInseparable.surjective_algebraMap_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u_1) (E : Type u_2) [inst : CommRing F] [inst_1 : Ring E] [inst_2 : Algebra F E] [IsPurelyInseparable F E]
[Algebra.IsSeparable F E], Function.Surjective ⇑(algebraMap F E) | If `E / F` is both purely inseparable and separable, then `algebraMap F E` is surjective. | true |
instMulOneClassWithConvMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_3} {n : Type u_2} {α : Type u_1} [inst : MulOneClass α] (a : WithConv (Matrix m n α)), 1 * a = a | null | false |
CategoryTheory.Lax.OplaxTrans.homCategory._proof_4 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {X Y : F ⟶ G} (f : CategoryTheory.Lax.OplaxTrans.Hom X Y),
{ as := f.as.vcomp { as := CategoryTheory.Lax.OplaxTrans.Modification.id Y }.as } = f | null | false |
Lean.Order.CompleteLattice.casesOn | Init.Internal.Order.Basic | {α : Sort u} →
{motive : Lean.Order.CompleteLattice α → Sort u_1} →
(t : Lean.Order.CompleteLattice α) →
([toPartialOrder : Lean.Order.PartialOrder α] →
(has_sup : ∀ (c : α → Prop), Exists (Lean.Order.is_sup c)) →
motive { toPartialOrder := toPartialOrder, has_sup := has_sup }) →
... | null | false |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.loopyOn_isLoopless_iff._simp_1_1 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α}, M.Loopless = ∀ e ∈ M.E, ¬M.IsLoop e | null | false |
Matrix.transpose_fromRows | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} (A₁ : Matrix m₁ n R) (A₂ : Matrix m₂ n R),
(A₁.fromRows A₂).transpose = A₁.transpose.fromCols A₂.transpose | A row partitioned matrix when transposed gives a column partitioned matrix with rows of the
initial matrix transposed to become columns. | true |
CategoryTheory.SmallObject.ιFunctorObj_eq | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (κ : Cardinal.{w})
[inst_1 : Fact κ.IsRegular] [inst_2 : OrderBot κ.ord.ToType] [inst_3 : I.IsCardinalForSmallObjectArgument κ] {X Y : C}
(f : X ⟶ Y) (j : κ.ord.ToType),
CategoryTheory.SmallObject.ιFunctorObj I.homFam... | null | true |
LinearMap.ofIsCompl_eq_add | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {p q : Submodule R E} (hpq : IsCompl p q) {φ : ↥p →ₗ[R] F}
{ψ : ↥q →ₗ[R] F}, LinearMap.ofIsCompl hpq φ ψ = φ ∘ₗ p.projectionOnto q hpq + ψ ∘ₗ q.projectionOnt... | null | true |
CategoryTheory.Mon.limit._proof_3 | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.MonoidalCategory C]
(F : CategoryTheory.Functor J (CategoryTheory.Mon C))
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Mon.forget C))) (i j : J) (f : i ... | null | false |
RingEquiv.prodProdProdComm._proof_3 | Mathlib.Algebra.Ring.Prod | ∀ (R : Type u_2) (R' : Type u_1) (S : Type u_4) (S' : Type u_3) [inst : NonAssocSemiring R]
[inst_1 : NonAssocSemiring S] [inst_2 : NonAssocSemiring R'] [inst_3 : NonAssocSemiring S'] (x y : (R × R') × S × S'),
(MulEquiv.prodProdProdComm R R' S S').toFun (x * y) =
(MulEquiv.prodProdProdComm R R' S S').toFun x *... | null | false |
instLocallyFiniteOrderBotSubtypeLtOfDecidableLTOfLocallyFiniteOrder._proof_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] {y : α} [inst_1 : DecidableLT α] [inst_2 : LocallyFiniteOrder α]
(a b : { x // y < x }), b ∈ Finset.subtype (fun x => y < x) (Finset.Ioc y ↑a) ↔ b ≤ a | null | false |
_private.Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily.0.CategoryTheory.PreZeroHypercoverFamily.mem_precoverage_iff.match_1_1 | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {P : CategoryTheory.PreZeroHypercoverFamily C} {X : C}
(motive : (R : CategoryTheory.Presieve X) → R ∈ P.precoverage.coverings X → Prop) (R : CategoryTheory.Presieve X)
(x : R ∈ P.precoverage.coverings X),
(∀ (E : CategoryTheory.PreZeroHypercover X) (... | null | false |
IO.FS.Mode.recOn | Init.System.IO | {motive : IO.FS.Mode → Sort u} →
(t : IO.FS.Mode) →
motive IO.FS.Mode.read →
motive IO.FS.Mode.write →
motive IO.FS.Mode.writeNew → motive IO.FS.Mode.readWrite → motive IO.FS.Mode.append → motive t | null | false |
RingPreordering.supportAddSubgroup._proof_2 | Mathlib.Algebra.Order.Ring.Ordering.Defs | ∀ {R : Type u_1} [inst : CommRing R] (P : RingPreordering R) {a b : R}, a ∈ ↑P ∩ -↑P → b ∈ ↑P ∩ -↑P → a + b ∈ ↑P ∩ -↑P | null | false |
Vector.flatMap_push | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {m : ℕ} {xs : Vector α n} {x : α} {f : α → Vector β m},
(xs.push x).flatMap f = Vector.cast ⋯ (xs.flatMap f ++ f x) | null | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Raw.Internal.foldRev.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} (f : δ → (a : α) → β a → δ) (init : δ) (b : Std.DHashMap.Raw α β),
Std.DHashMap.Raw.Internal.foldRev f init b =
(Std.DHashMap.Raw.Internal.foldRevM (fun x1 x2 x3 => pure (f x1 x2 x3)) init b).run | null | true |
UInt8.reduceAdd | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Meta.Simp.DSimproc | null | true |
LocallyConstant.desc | Mathlib.Topology.LocallyConstant.Basic | {X : Type u_5} →
{α : Type u_6} →
{β : Type u_7} →
[inst : TopologicalSpace X] →
{g : α → β} → (f : X → α) → (h : LocallyConstant X β) → g ∘ f = ⇑h → Function.Injective g → LocallyConstant X α | If a locally constant function factors through an injection, then it factors through a locally
constant function. | true |
Subgroup.map_subtype_le_map_subtype | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : Group G] {G' : Subgroup G} {H K : Subgroup ↥G'},
Subgroup.map G'.subtype H ≤ Subgroup.map G'.subtype K ↔ H ≤ K | null | true |
DFinsupp.filter.congr_simp | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] (p p_1 : ι → Prop),
p = p_1 →
∀ {inst_1 : DecidablePred p} [inst_2 : DecidablePred p_1] (x x_1 : Π₀ (i : ι), β i),
x = x_1 → DFinsupp.filter p x = DFinsupp.filter p_1 x_1 | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Stirling.0.Stirling.log_stirlingSeq_bounded_aux._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Stirling | ∀ (n : ℕ), 0 ≤ ↑n + 1 | null | false |
LucasLehmer.X.add_snd | Mathlib.NumberTheory.LucasLehmer | ∀ {q : ℕ} (x y : LucasLehmer.X q), (x + y).2 = x.2 + y.2 | null | true |
CategoryTheory.Lax.OplaxTrans.LaxFunctor.bicategory_leftUnitor_inv_as_app | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C]
{x x_1 : CategoryTheory.LaxFunctor B C} (η : x ⟶ x_1) (a : B),
(CategoryTheory.Bicategory.leftUnitor η).inv.as.app a = (CategoryTheory.Bicategory.leftUnitor (η.app a)).inv | null | true |
ComplexShape.TensorSigns.casesOn | Mathlib.Algebra.Homology.ComplexShapeSigns | {I : Type u_7} →
[inst : AddMonoid I] →
{c : ComplexShape I} →
{motive : c.TensorSigns → Sort u} →
(t : c.TensorSigns) →
((ε' : Multiplicative I →* ℤˣ) →
(rel_add : ∀ (p q r : I), c.Rel p q → c.Rel (p + r) (q + r)) →
(add_rel : ∀ (p q r : I), c.Rel p q → c.Rel... | null | false |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.cmp_veblenWith.match_1.eq_2 | Mathlib.SetTheory.Ordinal.Veblen | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.eq) (h_2 : Unit → motive Ordering.lt)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.lt with
| Ordering.eq => h_1 ()
| Ordering.lt => h_2 ()
| Ordering.gt => h_3 ()) =
h_2 () | null | true |
Lean.Expr.updateForall! | Lean.Expr | Lean.Expr → Lean.BinderInfo → Lean.Expr → Lean.Expr → Lean.Expr | null | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_190 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] {g (g a)}.card + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] {g (g a)}.card < (List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).l... | null | false |
CategoryTheory.Subobject.ofLEMk_comp | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} {X : CategoryTheory.Subobject B} {f : A ⟶ B}
[inst_1 : CategoryTheory.Mono f] (h : X ≤ CategoryTheory.Subobject.mk f),
CategoryTheory.CategoryStruct.comp (X.ofLEMk f h) f = X.arrow | null | true |
HahnSeries.SummableFamily.embDomain | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_1} →
{R : Type u_3} →
{α : Type u_5} →
{β : Type u_6} →
[inst : PartialOrder Γ] →
[inst_1 : AddCommMonoid R] → HahnSeries.SummableFamily Γ R α → (α ↪ β) → HahnSeries.SummableFamily Γ R β | A summable family can be reindexed by an embedding without changing its sum. | true |
_private.Mathlib.Data.DFinsupp.Defs.0.DFinsupp.filter_single._proof_1_2 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_1} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] (p : ι → Prop)
[inst_2 : DecidablePred p] (i : ι) (x : β i) (j : ι),
((if p i then fun₀ | i => x else 0) j = if p i then (fun₀ | i => x) j else 0) →
(DFinsupp.filter p fun₀ | i => x) j = (if p i then fun₀ | i => x else 0)... | null | false |
_private.Mathlib.Analysis.Normed.Group.Basic.0.enorm'_eq_iff_norm_eq._simp_1_1 | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] (x : E), ‖x‖ₑ = ENNReal.ofReal ‖x‖ | null | false |
StarSubalgebra.ofClass._proof_4 | Mathlib.Algebra.Star.Subalgebra | ∀ {S : Type u_2} {A : Type u_1} [inst : Semiring A] [inst_1 : SetLike S A] [SubsemiringClass S A] (s : S), 0 ∈ s | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable.0.EisensteinSeries.tendsto_double_sum_S_act._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ},
Filter.Tendsto f (Filter.map g x) y = Filter.Tendsto (f ∘ g) x y | null | false |
ENat.toENNReal_strictMono | Mathlib.Data.Real.ENatENNReal | StrictMono ENat.toENNReal | null | true |
CategoryTheory.CommRingObjCat.instCategory | Mathlib.CategoryTheory.Monoidal.Ring | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
CategoryTheory.Category.{v, max u v} (CategoryTheory.CommRingObjCat C) | null | true |
MeasureTheory.tendstoInDistribution_of_isEmpty | Mathlib.MeasureTheory.Function.ConvergenceInDistribution | ∀ {ι : Type u_1} {E : Type u_2} {Ω' : Type u_3} {Ω : ι → Type u_5} {m : (i : ι) → MeasurableSpace (Ω i)}
{μ : (i : ι) → MeasureTheory.Measure (Ω i)} [inst : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)]
{m' : MeasurableSpace Ω'} {μ' : MeasureTheory.Measure Ω'} [inst_1 : MeasureTheory.IsProbabilityMeasure μ']... | null | true |
Lean.Elab.Tactic.throwOrLogError | Lean.Elab.Tactic.Basic | Lean.MessageData → Lean.Elab.Tactic.TacticM Unit | Like `throwError`, but, if recovery is enabled, logs the error instead.
| true |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.IsCycle.commute_iff._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {G : Type u_1} [inst : Group G] {g h : G}, (h ∈ Subgroup.zpowers g) = ∃ k, g ^ k = h | null | false |
descPochhammer_one | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (R : Type u) [inst : Ring R], descPochhammer R 1 = Polynomial.X | null | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State.mk.inj | Lean.Meta.Tactic.Simp.Arith.Int.Basic | ∀ {varMap : Lean.Meta.KExprMap ℕ} {vars : Array Lean.Expr} {varMap_1 : Lean.Meta.KExprMap ℕ} {vars_1 : Array Lean.Expr},
{ varMap := varMap, vars := vars } = { varMap := varMap_1, vars := vars_1 } → varMap = varMap_1 ∧ vars = vars_1 | null | true |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.lt_find_iff._simp_1_2 | Mathlib.Data.Fin.Tuple.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
AddCommMonCat.instConcreteCategoryAddMonoidHomCarrier._proof_2 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : AddCommMonCat} (f : X ⟶ Y), { hom' := f.hom' } = f | null | false |
CategoryTheory.Limits.PreservesWellOrderContinuousOfShape.preservesColimitsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Preorder | ∀ {C : Type u} {D : Type u'} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.Category.{v', u'} D}
{J : Type w} {inst_2 : LinearOrder J} {G : CategoryTheory.Functor C D}
[self : CategoryTheory.Limits.PreservesWellOrderContinuousOfShape J G] (j : J),
Order.IsSuccLimit j → CategoryTheory.Limits.Pr... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite.0.SimpleGraph.IsPathGraph3Compl.pathGraph3ComplEmbedding.match_1.splitter | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | (motive : Fin 3 → Sort u_1) → (x : Fin 3) → (Unit → motive 0) → (Unit → motive 1) → (Unit → motive 2) → motive x | null | true |
Lean.EnvironmentHeader.imports._default | Lean.Environment | Array Lean.Import | null | false |
Lean.IR.instToFormatCtorInfo | Lean.Compiler.IR.Format | Std.ToFormat Lean.IR.CtorInfo | null | true |
Set.fintypeUnion._proof_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Set α) [inst_1 : Fintype ↑s] [inst_2 : Fintype ↑t] (x : α),
x ∈ s.toFinset ∪ t.toFinset ↔ x ∈ s ∪ t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.