name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.PrettyPrinter.Delaborator.delabAppExplicitCore | Lean.PrettyPrinter.Delaborator.Builtins | Bool →
ℕ →
(Bool → Lean.PrettyPrinter.Delaborator.Delab) →
Array Lean.PrettyPrinter.Delaborator.ParamKind → Lean.PrettyPrinter.Delaborator.Delab |
Polynomial.card_support_trinomial | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u} [inst : Semiring R] {k m n : ℕ},
k < m →
m < n →
∀ {x y z : R},
x ≠ 0 →
y ≠ 0 →
z ≠ 0 →
(Polynomial.C x * Polynomial.X ^ k + Polynomial.C y * Polynomial.X ^ m +
Polynomial.C z * Polynomial.X ^ n).support.card =
3 |
exists_eq_smul_of_parallel | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {p₁ p₂ p₃ p₄ p₅ p₆ : P},
p₂ ∉ affineSpan k {p₁, p₃} →
(affineSpan k {p₁, p₂}).Parallel (affineSpan k {p₄, p₅}) →
(affineSpan k {p₅, p₆}).direction ≤ (affineSpan k {p₂, p₃}).direction →
(affineSpan k {p₆, p₄}).direction ≤ (affineSpan k {p₃, p₁}).direction →
∃ r, r ≠ 0 ∧ p₅ -ᵥ p₄ = r • (p₂ -ᵥ p₁) ∧ p₆ -ᵥ p₅ = r • (p₃ -ᵥ p₂) ∧ p₄ -ᵥ p₆ = r • (p₁ -ᵥ p₃) |
Function.support_comp_eq_preimage | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : Zero M] (g : κ → M) (f : ι → κ),
Function.support (g ∘ f) = f ⁻¹' Function.support g |
MeasureTheory.L1.integral_eq' | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {E : Type u_2} (𝕜 : Type u_4) [inst : NormedAddCommGroup E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [inst_1 : NormedSpace ℝ E] [inst_2 : NormedRing 𝕜] [inst_3 : Module 𝕜 E]
[inst_4 : IsBoundedSMul 𝕜 E] [inst_5 : SMulCommClass ℝ 𝕜 E] [inst_6 : CompleteSpace E]
(f : ↥(MeasureTheory.Lp E 1 μ)), MeasureTheory.L1.integral f = (MeasureTheory.L1.integralCLM' 𝕜) f |
RegularExpression.matches'_zero | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1}, RegularExpression.matches' 0 = 0 |
SheafOfModules.Hom._sizeOf_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} → {X Y : SheafOfModules R} → [SizeOf C] → X.Hom Y → ℕ |
_private.Mathlib.RingTheory.Frobenius.0.AlgHom.IsArithFrobAt.isArithFrobAt_localize._simp_1_3 | Mathlib.RingTheory.Frobenius | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} {a : R} [inst_1 : I.IsTwoSided], (a ∈ I) = ((Ideal.Quotient.mk I) a = 0) |
CategoryTheory.Pseudofunctor.hasCoeToOplax | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → Coe (CategoryTheory.Pseudofunctor B C) (CategoryTheory.OplaxFunctor B C) |
AddMonCat.coe_of | Mathlib.Algebra.Category.MonCat.Basic | ∀ (M : Type u) [inst : AddMonoid M], ↑(AddMonCat.of M) = M |
_private.Lean.Environment.0.Lean.mkIRData | Lean.Environment | Lean.Environment → Lean.ModuleData |
_private.Std.Data.DHashMap.Internal.WF.0.Std.Internal.List.alterKey.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] (k : α) (f : Option (β k) → Option (β k))
(l : List ((a : α) × β a)),
Std.Internal.List.alterKey k f l =
match f (Std.Internal.List.getValueCast? k l) with
| none => Std.Internal.List.eraseKey k l
| some v => Std.Internal.List.insertEntry k v l |
LocallyFiniteOrder.ofOrderIsoClass | Mathlib.Order.Interval.Finset.Defs | {F : Type u_3} →
{M : Type u_4} →
{N : Type u_5} →
[inst : Preorder M] →
[inst_1 : Preorder N] →
[inst_2 : EquivLike F M N] → [OrderIsoClass F M N] → F → [LocallyFiniteOrder N] → LocallyFiniteOrder M |
_private.Mathlib.Data.Finset.Basic.0.Multiset.toFinset_nonempty._simp_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} {s : Finset α}, s.Nonempty = (s ≠ ∅) |
CategoryTheory.Limits.reflectsCofilteredLimitsOfSize_of_univLE | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [UnivLE.{w, w'}] [UnivLE.{w₂, w₂'}]
[CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize.{w', w₂', v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize.{w, w₂, v₁, v₂, u₁, u₂} F |
CategoryTheory.ShortComplex.homologyFunctorOpNatIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.CategoryWithHomology C] (S : (CategoryTheory.ShortComplex C)ᵒᵖ), (Opposite.unop S).op.HasHomology |
SimpleGraph.induceHom | 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') → Set.MapsTo (⇑φ) s t → SimpleGraph.induce s G →g SimpleGraph.induce t G' |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.mkSimpOnly.match_11 | Lean.Elab.Tactic.Simp | (motive : MProd (Array (Lean.TSyntax `Lean.Parser.Tactic.simpLemma)) (Option (Array Lean.Name)) → Sort u_1) →
(r : MProd (Array (Lean.TSyntax `Lean.Parser.Tactic.simpLemma)) (Option (Array Lean.Name))) →
((args : Array (Lean.TSyntax `Lean.Parser.Tactic.simpLemma)) →
(localsOrStar : Option (Array Lean.Name)) → motive ⟨args, localsOrStar⟩) →
motive r |
_private.Mathlib.NumberTheory.LSeries.MellinEqDirichlet.0.hasSum_mellin_pi_mul_sq'._simp_1_5 | Mathlib.NumberTheory.LSeries.MellinEqDirichlet | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False |
_private.Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms.0.CategoryTheory.Limits.HasZeroMorphisms.ext_aux | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I J : CategoryTheory.Limits.HasZeroMorphisms C),
(∀ (X Y : C), Zero.zero = Zero.zero) → I = J |
Matrix.IsPrimitive.mk._flat_ctor | Mathlib.LinearAlgebra.Matrix.Irreducible.Defs | ∀ {n : Type u_1} {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : Fintype n] [inst_3 : DecidableEq n]
{A : Matrix n n R}, (∀ (i j : n), 0 ≤ A i j) → (∃ k > 0, ∀ (i j : n), 0 < (A ^ k) i j) → A.IsPrimitive |
Lean.Compiler.LCNF.FunDecl.mk.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fvarId : Lean.FVarId} →
{binderName : Lean.Name} →
{params : Array (Lean.Compiler.LCNF.Param pu)} →
{type : Lean.Expr} →
{value : Lean.Compiler.LCNF.Code pu} →
{fvarId' : Lean.FVarId} →
{binderName' : Lean.Name} →
{params' : Array (Lean.Compiler.LCNF.Param pu)} →
{type' : Lean.Expr} →
{value' : Lean.Compiler.LCNF.Code pu} →
Lean.Compiler.LCNF.FunDecl.mk fvarId binderName params type value =
Lean.Compiler.LCNF.FunDecl.mk fvarId' binderName' params' type' value' →
(fvarId = fvarId' →
binderName = binderName' → params ≍ params' → type = type' → value ≍ value' → P) →
P |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.equivIntOfUnique._simp_2 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b |
Filter.Germ.instMonoid.eq_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_5} [inst : Monoid M],
Filter.Germ.instMonoid =
{ toSemigroup := Filter.Germ.instSemigroup, toOne := Filter.Germ.instOne, one_mul := ⋯, mul_one := ⋯,
npow := fun n a => a ^ n, npow_zero := ⋯, npow_succ := ⋯ } |
Valuation.Integers.integrallyClosed | Mathlib.RingTheory.Valuation.Integral | ∀ {K : Type u} {Γ₀ : Type v} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation K Γ₀}
{O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O K], v.Integers O → IsIntegrallyClosed O |
CategoryTheory.Distributive._aux_Mathlib_CategoryTheory_Distributive_Monoidal___unexpand_CategoryTheory_leftDistrib_1 | Mathlib.CategoryTheory.Distributive.Monoidal | Lean.PrettyPrinter.Unexpander |
CategoryTheory.LaxBraidedFunctor.comp_hom | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{F G H : CategoryTheory.LaxBraidedFunctor C D} (α : F ⟶ G) (β : G ⟶ H),
(CategoryTheory.CategoryStruct.comp α β).hom = CategoryTheory.CategoryStruct.comp α.hom β.hom |
Aesop.evalAesop | Aesop.Main | Lean.Elab.Tactic.Tactic |
CategoryTheory.kernelCokernelCompSequence.snakeInput_L₁_g | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z), (CategoryTheory.kernelCokernelCompSequence.snakeInput f g).L₁.g = CategoryTheory.Limits.biprod.snd |
WCovBy.Ioo_eq | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ⩿ b → Set.Ioo a b = ∅ |
MonCat.HasLimits.limitConeIsLimit._proof_2 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J MonCat)
(s : CategoryTheory.Limits.Cone F) (v : ((CategoryTheory.forget MonCat).mapCone s).pt) {j j' : J} (f : j ⟶ j'),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.forget MonCat).mapCone s).π.app j)
((F.comp (CategoryTheory.forget MonCat)).map f) v =
((CategoryTheory.forget MonCat).mapCone s).π.app j' v |
Lean.DeclarationRanges.mk.inj | Lean.Data.DeclarationRange | ∀ {range selectionRange range_1 selectionRange_1 : Lean.DeclarationRange},
{ range := range, selectionRange := selectionRange } = { range := range_1, selectionRange := selectionRange_1 } →
range = range_1 ∧ selectionRange = selectionRange_1 |
ENNReal.le_toNNReal_of_coe_le | Mathlib.Data.ENNReal.Real | ∀ {a : ENNReal} {p : NNReal}, ↑p ≤ a → a ≠ ⊤ → p ≤ a.toNNReal |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.isCoprime_biInf._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R}, IsCoprime I J = (I + J = 1) |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.u₁ | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} →
{hζ : IsPrimitiveRoot ζ 3} →
FermatLastTheoremForThreeGen.Solution hζ →
[inst_1 : NumberField K] → [IsCyclotomicExtension {3} ℚ K] → (NumberField.RingOfIntegers K)ˣ |
Int.dvd_negSucc._simp_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℤ} {b : ℕ}, (a ∣ Int.negSucc b) = (a ∣ ↑(b + 1)) |
_private.ProofWidgets.Data.Html.0.ProofWidgets.Jsx.transformTag.match_10 | ProofWidgets.Data.Html | (motive : Lean.Ident × Lean.Term → Sort u_1) →
(x : Lean.Ident × Lean.Term) → ((k : Lean.Ident) → (v : Lean.Term) → motive (k, v)) → motive x |
_private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.range_natCast._simp_1_4 | Mathlib.SetTheory.Cardinal.Basic | ∀ {c : Cardinal.{u_1}}, (c < Cardinal.aleph0) = ∃ n, c = ↑n |
CategoryTheory.Prod.braiding | Mathlib.CategoryTheory.Products.Basic | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → C × D ≌ D × C |
_private.Mathlib.Data.Finset.Lattice.Fold.0.Finset.lt_sup_iff.match_1_5 | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {ι : Type u_1} [inst : LinearOrder α] {s : Finset ι} {f : ι → α} {a : α}
(motive : (∃ b ∈ s, a < f b) → Prop) (x : ∃ b ∈ s, a < f b),
(∀ (b : ι) (hb : b ∈ s) (hlt : a < f b), motive ⋯) → motive x |
_private.Mathlib.Analysis.Normed.Unbundled.FiniteExtension.0.Module.Basis.norm_nonneg._simp_1_5 | Mathlib.Analysis.Normed.Unbundled.FiniteExtension | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∃ x, b) = b |
Multiset.toFinsupp._proof_2 | Mathlib.Data.Finsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Multiset α),
(fun f => Finsupp.toMultiset f)
((fun s => { support := s.toFinset, toFun := fun a => Multiset.count a s, mem_support_toFun := ⋯ }) s) =
s |
isSimplyConnected_smul_set₀_iff._simp_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {G : Type u_3} [inst_1 : GroupWithZero G] [inst_2 : MulAction G X]
[ContinuousConstSMul G X] {c : G} {s : Set X}, c ≠ 0 → IsSimplyConnected (c • s) = IsSimplyConnected s |
_private.Mathlib.RingTheory.PowerSeries.Basic.0.Polynomial.coe_injective._simp_1_1 | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] (φ : Polynomial R) (n : ℕ), φ.coeff n = (PowerSeries.coeff n) ↑φ |
IsCornerFree.eq_1 | Mathlib.Combinatorics.Additive.Corner.Roth | ∀ {G : Type u_1} [inst : AddCommMonoid G] (A : Set (G × G)),
IsCornerFree A = ∀ ⦃x₁ y₁ x₂ y₂ : G⦄, IsCorner A x₁ y₁ x₂ y₂ → x₁ = x₂ |
QuadraticAlgebra.mk_mul_mk | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : Mul R] [inst_1 : Add R] (x1 y1 x2 y2 : R),
{ re := x1, im := y1 } * { re := x2, im := y2 } =
{ re := x1 * x2 + a * y1 * y2, im := x1 * y2 + y1 * x2 + b * y1 * y2 } |
Int.sub_mul_bmod_self_right | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ) (c : ℕ), (a - b * ↑c).bmod c = a.bmod c |
Mathlib.Tactic.ITauto.Proof.noConfusion | Mathlib.Tactic.ITauto | {P : Sort u} → {t t' : Mathlib.Tactic.ITauto.Proof} → t = t' → Mathlib.Tactic.ITauto.Proof.noConfusionType P t t' |
Lean.Elab.evalSyntaxConstant | Lean.Elab.Util | Lean.Environment → Lean.Options → Lean.Name → ExceptT String Id Lean.Syntax |
Subgroup.instEncodableSubtypeMulOppositeMemOp.eq_1 | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | ∀ {G : Type u_2} [inst : Group G] (H : Subgroup G) [inst_1 : Encodable ↥H],
H.instEncodableSubtypeMulOppositeMemOp = Encodable.ofEquiv (↥H) H.equivOp.symm |
CategoryTheory.ShortComplex.LeftHomologyData.ofZeros_H | 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) (hf : S.f = 0) (hg : S.g = 0),
(CategoryTheory.ShortComplex.LeftHomologyData.ofZeros S hf hg).H = S.X₂ |
IsCoprime.of_mul_left_left | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x y z : R}, IsCoprime (x * y) z → IsCoprime x z |
Std.DHashMap.Internal.Raw.size_eq_length | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β},
Std.DHashMap.Internal.Raw.WFImp m → m.size = (Std.DHashMap.Internal.toListModel m.buckets).length |
Lean.Grind.GrobnerConfig.qlia._inherited_default | Init.Grind.Config | Bool |
Representation.TensorProduct.comm_symm | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : CommSemiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W),
(Representation.TensorProduct.comm σ ρ).symm = Representation.TensorProduct.comm ρ σ |
_private.Mathlib.MeasureTheory.Integral.CircleIntegral.0.circleIntegral.circleIntegral_congr_codiscreteWithin._simp_1_1 | Mathlib.MeasureTheory.Integral.CircleIntegral | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsLeftCancelMulZero M₀] {a b c : M₀}, (a * b = a * c) = (b = c ∨ a = 0) |
OrderIso.prodComm | Mathlib.Order.Hom.Basic | {α : Type u_2} → {β : Type u_3} → [inst : LE α] → [inst_1 : LE β] → α × β ≃o β × α |
CategoryTheory.Functor.leftKanExtensionIsoFiberwiseColimit_hom_app | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension F] [inst_4 : L.HasLeftKanExtension F] (X : D),
(L.leftKanExtensionIsoFiberwiseColimit F).hom.app X =
CategoryTheory.CategoryStruct.comp (L.leftKanExtensionObjIsoColimit F X).hom
(CategoryTheory.Limits.HasColimit.isoOfNatIso
(CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.CostructuredArrow.ιCompGrothendieckProj L X) F)).inv |
floorDiv_one | Mathlib.Algebra.Order.Floor.Div | ∀ {α : Type u_2} {β : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : AddCommMonoid β]
[inst_3 : PartialOrder β] [inst_4 : MulActionWithZero α β] [inst_5 : FloorDiv α β] [IsOrderedRing α] [Nontrivial α]
(b : β), b ⌊/⌋ 1 = b |
Nat._aux_Mathlib_Algebra_Order_Floor_Defs___unexpand_Nat_floor_1 | Mathlib.Algebra.Order.Floor.Defs | Lean.PrettyPrinter.Unexpander |
_private.Mathlib.Topology.Instances.Real.Lemmas.0.closure_ordConnected_inter_rat._simp_1_5 | Mathlib.Topology.Instances.Real.Lemmas | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a b c : α}, (a - b < c) = (a - c < b) |
IntermediateField.sInf_toSubalgebra | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E]
(S : Set (IntermediateField F E)), (sInf S).toSubalgebra = sInf (IntermediateField.toSubalgebra '' S) |
Lean.Grind.Linarith.zero_ne_one_of_charC_cert.eq_1 | Init.Grind.Ordered.Linarith | ∀ (c : ℕ) (p : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.zero_ne_one_of_charC_cert c p =
(decide (↑c > 1) && p == Lean.Grind.Linarith.Poly.add 1 0 Lean.Grind.Linarith.Poly.nil) |
CochainComplex.HomComplex.Cochain.shift_units_smul | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {R : Type u_1}
[inst_2 : Ring R] [inst_3 : CategoryTheory.Linear R C] {K L : CochainComplex C ℤ} {n : ℤ}
(γ : CochainComplex.HomComplex.Cochain K L n) (a : ℤ) (x : Rˣ), (x • γ).shift a = x • γ.shift a |
DistribSMul.mk.noConfusion | Mathlib.Algebra.GroupWithZero.Action.Defs | {M : Type u_12} →
{A : Type u_13} →
{inst : AddZeroClass A} →
{P : Sort u} →
{toSMulZeroClass : SMulZeroClass M A} →
{smul_add : ∀ (a : M) (x y : A), a • (x + y) = a • x + a • y} →
{toSMulZeroClass' : SMulZeroClass M A} →
{smul_add' : ∀ (a : M) (x y : A), a • (x + y) = a • x + a • y} →
{ toSMulZeroClass := toSMulZeroClass, smul_add := smul_add } =
{ toSMulZeroClass := toSMulZeroClass', smul_add := smul_add' } →
(toSMulZeroClass ≍ toSMulZeroClass' → P) → P |
List.take_take | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {i j : ℕ} {l : List α}, List.take i (List.take j l) = List.take (min i j) l |
DifferentiableWithinAt.clm_comp | Mathlib.Analysis.Calculus.FDeriv.CompCLM | ∀ {𝕜 : 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] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : E} {s : Set E} {H : Type u_5}
[inst_7 : NormedAddCommGroup H] [inst_8 : NormedSpace 𝕜 H] {c : E → G →L[𝕜] H} {d : E → F →L[𝕜] G},
DifferentiableWithinAt 𝕜 c s x →
DifferentiableWithinAt 𝕜 d s x → DifferentiableWithinAt 𝕜 (fun y => (c y).comp (d y)) s x |
Nat.ModEq.listProd_one | Mathlib.Algebra.BigOperators.ModEq | ∀ {n : ℕ} {l : List ℕ}, (∀ x ∈ l, x ≡ 1 [MOD n]) → l.prod ≡ 1 [MOD n] |
eq_true_of_ne_false | Init.Prelude | ∀ {b : Bool}, ¬b = false → b = true |
DoubleCentralizer.nnnorm_def' | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] (a : DoubleCentralizer 𝕜 A),
‖a‖₊ = ‖DoubleCentralizer.toProdMulOppositeHom a‖₊ |
_private.Lean.Meta.Tactic.Grind.Inv.0.Lean.Meta.Grind.checkChild | Lean.Meta.Tactic.Grind.Inv | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool |
Matrix.reindexLinearEquiv_mul | Mathlib.LinearAlgebra.Matrix.Reindex | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {m' : Type u_6} {n' : Type u_7} {o' : Type u_8} (R : Type u_11)
(A : Type u_12) [inst : Semiring R] [inst_1 : Semiring A] [inst_2 : Module R A] [inst_3 : Fintype n]
[inst_4 : Fintype n'] (eₘ : m ≃ m') (eₙ : n ≃ n') (eₒ : o ≃ o') (M : Matrix m n A) (N : Matrix n o A),
(Matrix.reindexLinearEquiv R A eₘ eₙ) M * (Matrix.reindexLinearEquiv R A eₙ eₒ) N =
(Matrix.reindexLinearEquiv R A eₘ eₒ) (M * N) |
Std.HashMap.Raw.getKeyD_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α Unit} [EquivBEq α] [LawfulHashable α],
m.WF →
∀ {l : List α} {k k' fallback : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (m.insertManyIfNewUnit l).getKeyD k' fallback = k |
LinearMap.IsPosSemidef.add | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {I₁ : R →+* R}
[inst_3 : Preorder R] [AddLeftMono R] {B C : M →ₛₗ[I₁] M →ₗ[R] R},
B.IsPosSemidef → C.IsPosSemidef → (B + C).IsPosSemidef |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary.eq_def | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} (iM : Q(CommGroupWithZero «$M»))
(_x : (_ : Mathlib.Tactic.FieldSimp.qNF M) ×' Mathlib.Tactic.FieldSimp.qNF M),
Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary iM _x =
PSigma.casesOn _x fun l₁ l₂ =>
match l₁, l₂ with
| [], l =>
have a := l.toNF;
q(⋯)
| l, [] =>
have a := l.toNF;
q(⋯)
| ((a₁, x₁), k₁) :: t₁, ((a₂, x₂), k₂) :: t₂ =>
if k₁ > k₂ then
have pf := Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary iM ⟨t₁, ((a₂, x₂), k₂) :: t₂⟩;
q(⋯)
else
if k₁ = k₂ then
have pf := Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary iM ⟨t₁, t₂⟩;
q(⋯)
else
have pf := Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary iM ⟨((a₁, x₁), k₁) :: t₁, t₂⟩;
q(⋯) |
CategoryTheory.Oplax.LaxTrans.Hom.as | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} → CategoryTheory.Oplax.LaxTrans.Hom η θ → CategoryTheory.Oplax.LaxTrans.Modification η θ |
CategoryTheory.Limits.FintypeCat.inclusion_preservesFiniteColimits | Mathlib.CategoryTheory.Limits.FintypeCat | CategoryTheory.Limits.PreservesFiniteColimits FintypeCat.incl |
Std.TreeMap.Raw.getElem!_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited β], t.WF → ∀ {k a : α} {v : β}, (t.insert k v)[a]! = if cmp k a = Ordering.eq then v else t[a]! |
MeasureTheory.integrableOn_iff_comap_subtypeVal | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_3} {mα : MeasurableSpace α} {f : α → ε} {s : Set α} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε],
MeasurableSet s →
(MeasureTheory.IntegrableOn f s μ ↔
MeasureTheory.Integrable (f ∘ Subtype.val) (MeasureTheory.Measure.comap Subtype.val μ)) |
LieIdeal.mem_rootSet | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : LieRing L] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra] {I : LieIdeal K L}
{α : ↥LieSubalgebra.root}, α ∈ I.rootSet ↔ LieAlgebra.rootSpace H ⇑↑α ≤ LieSubmodule.restr I H |
CategoryTheory.Subfunctor.IsFinite.x._proof_1 | Mathlib.CategoryTheory.Subfunctor.Finite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {F : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
{G : CategoryTheory.Subfunctor F} [hG : G.IsFinite], ∃ x, Nonempty (G.IsGeneratedBy x) |
Matrix.IsStrictlyPositive.posDef | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {x : Matrix n n 𝕜},
IsStrictlyPositive x → x.PosDef |
CategoryTheory.GrothendieckTopology.OneHypercover.recOn | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{S : C} →
{motive : J.OneHypercover S → Sort u_1} →
(t : J.OneHypercover S) →
((toPreOneHypercover : CategoryTheory.PreOneHypercover S) →
(mem₀ : toPreOneHypercover.sieve₀ ∈ J S) →
(mem₁ :
∀ (i₁ i₂ : toPreOneHypercover.I₀) ⦃W : C⦄ (p₁ : W ⟶ toPreOneHypercover.X i₁)
(p₂ : W ⟶ toPreOneHypercover.X i₂),
CategoryTheory.CategoryStruct.comp p₁ (toPreOneHypercover.f i₁) =
CategoryTheory.CategoryStruct.comp p₂ (toPreOneHypercover.f i₂) →
toPreOneHypercover.sieve₁ p₁ p₂ ∈ J W) →
motive { toPreOneHypercover := toPreOneHypercover, mem₀ := mem₀, mem₁ := mem₁ }) →
motive t |
_private.Mathlib.MeasureTheory.Covering.Vitali.0.Vitali.exists_disjoint_covering_ae'._proof_1_1 | Mathlib.MeasureTheory.Covering.Vitali | (2 + 1).AtLeastTwo |
FundamentalGroupoidFunctor.prodToProdTop | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | (A : TopCat) →
(B : TopCat) →
CategoryTheory.Functor
(↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A) ×
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj B))
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj (TopCat.of (↑A × ↑B))) |
ProofWidgets.MarkdownDisplay.Props.mk._flat_ctor | ProofWidgets.Component.Basic | String → ProofWidgets.MarkdownDisplay.Props |
BitVec.clzAuxRec._unsafe_rec | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → ℕ → BitVec w |
Set.instIrreflSSubset | Mathlib.Data.Set.Basic | ∀ {α : Type u}, Std.Irrefl fun x1 x2 => x1 ⊂ x2 |
_private.Lean.Elab.StructInstHint.0.Lean.Elab.Term.StructInst.FieldsHintView.casesOn | Lean.Elab.StructInstHint | {motive : Lean.Elab.Term.StructInst.FieldsHintView✝ → Sort u} →
(t : Lean.Elab.Term.StructInst.FieldsHintView✝¹) →
((initFieldPos? lastFieldTailPos? : Option String.Pos.Raw) →
(hasWith : Bool) →
(numFields : ℕ) →
(openingPos leaderPos leaderTailPos closingPos : String.Pos.Raw) →
motive
{ initFieldPos? := initFieldPos?, lastFieldTailPos? := lastFieldTailPos?, hasWith := hasWith,
numFields := numFields, openingPos := openingPos, leaderPos := leaderPos,
leaderTailPos := leaderTailPos, closingPos := closingPos }) →
motive t |
AlgebraicGeometry.geometrically_iff_of_commRing_of_isClosedUnderIsomorphisms | Mathlib.AlgebraicGeometry.Geometrically.Basic | ∀ {X : AlgebraicGeometry.Scheme} {P : CategoryTheory.ObjectProperty AlgebraicGeometry.Scheme} {R : Type u}
[inst : CommRing R] {f : X ⟶ AlgebraicGeometry.Spec (CommRingCat.of R)} [P.IsClosedUnderIsomorphisms],
AlgebraicGeometry.geometrically P f ↔
∀ (K : Type u) [inst_2 : Field K] [inst_3 : Algebra R K],
P (CategoryTheory.Limits.pullback f (AlgebraicGeometry.Spec.map (CommRingCat.ofHom (algebraMap R K)))) |
TensorProduct.addCommGroup._proof_5 | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M],
SMulCommClass R ℤ M |
Tactic.NormNum.NotPowerCertificate.pf_left | Mathlib.Tactic.NormNum.Irrational | {m n : Q(ℕ)} → (self : Tactic.NormNum.NotPowerCertificate m n) → Q(unknown_1 ^ «$n» < «$m») |
normEDSRec._proof_5 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ (x : ℕ), x + 5 < 2 * (x + 3) |
_private.Lean.Meta.Sym.AlphaShareBuilder.0.Lean.Expr.updateLambdaS!.match_1 | Lean.Meta.Sym.AlphaShareBuilder | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((n : Lean.Name) → (d b : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.lam n d b bi)) →
((x : Lean.Expr) → motive x) → motive e |
Option.bind_id_eq_join | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {x : Option (Option α)}, x.bind id = x.join |
instLatticeSubtypeIsIdempotentElem._proof_10 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommRing R] (a b c : { a // IsIdempotentElem a }), a ≤ b → a ≤ c → a ≤ SemilatticeInf.inf b c |
Real.logb_zero_left_eq_zero | Mathlib.Analysis.SpecialFunctions.Log.Base | Real.logb 0 = 0 |
Lean.Meta.Grind.EMatchTheoremConstraint.guard.inj | Lean.Meta.Tactic.Grind.Extension | ∀ {e e_1 : Lean.Expr},
Lean.Meta.Grind.EMatchTheoremConstraint.guard e = Lean.Meta.Grind.EMatchTheoremConstraint.guard e_1 → e = e_1 |
AlgebraicGeometry.Scheme.smallEtaleTopology | Mathlib.AlgebraicGeometry.Sites.Etale | (X : AlgebraicGeometry.Scheme) → CategoryTheory.GrothendieckTopology X.Etale |
LinearMap.IsSymmetric.id._simp_1 | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
LinearMap.id.IsSymmetric = True |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.