name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FiniteGaloisIntermediateField.adjoin_simple_le_iff | Mathlib.FieldTheory.Galois.GaloisClosure | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] [inst_3 : IsGalois k K]
{x : K} {L : FiniteGaloisIntermediateField k K},
FiniteGaloisIntermediateField.adjoin k {x} ≤ L ↔ x ∈ L.toIntermediateField | null | true |
lp.normedAddCommGroup._proof_18 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] [hp : Fact (1 ≤ p)],
∃ C,
∀ ⦃x : ↥(lp E p)⦄,
x ∈ ∅ →
∀ ⦃y : ↥(lp E p)⦄,
y ∈ ∅ →
{ toFun := norm, map_zero' := ⋯, add_le' := ⋯, neg' := ⋯, eq_zero_of_map_eq_zero' := ⋯ }.toAddGroupSemin... | null | false |
Finsupp.subtypeDomain_eq_zero_iff | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {p : α → Prop} {f : α →₀ M},
(∀ x ∈ f.support, p x) → (Finsupp.subtypeDomain p f = 0 ↔ f = 0) | null | true |
Vector.Mem.casesOn | Init.Data.Vector.Basic | {α : Type u_1} →
{n : ℕ} →
{xs : Vector α n} →
{a : α} → {motive : xs.Mem a → Sort u} → (t : xs.Mem a) → ((val : a ∈ xs.toArray) → motive ⋯) → motive t | null | false |
IsPrimitiveRoot.subOnePowerBasis | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | {n : ℕ} →
[NeZero n] →
(K : Type u) →
{L : Type v} →
[inst : Field K] →
[inst_1 : CommRing L] →
[IsDomain L] →
[inst_3 : Algebra K L] → [IsCyclotomicExtension {n} K L] → {ζ : L} → IsPrimitiveRoot ζ n → PowerBasis K L | The `PowerBasis` given by `η - 1`. | true |
CategoryTheory.HasLiftingProperty.transfiniteComposition.wellOrderInductionData.lift_f' | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X ⟶ Y} {f : F.obj ⊥ ⟶ X}
{g : c.pt ⟶ Y} [inst_3 : F.IsWellOrderContinuous] {j : J} (hj : Order.IsSuccLimit j)
(s... | null | true |
Std.Http.URI.instReprPath.repr | Std.Http.Data.URI.Basic | Std.Http.URI.Path → ℕ → Std.Format | null | true |
UniformSpaceCat.hom_ext | Mathlib.Topology.Category.UniformSpace | ∀ {X Y : UniformSpaceCat} {f g : X ⟶ Y},
⇑(CategoryTheory.ConcreteCategory.hom f) = ⇑(CategoryTheory.ConcreteCategory.hom g) → f = g | null | true |
Field.sepDegree_eq_of_isPurelyInseparable | Mathlib.FieldTheory.PurelyInseparable.Tower | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [IsPurelyInseparable F E],
Field.sepDegree F K = Field.sepDegree E K | If `K / E / F` is a field extension tower, such that `E / F` is purely inseparable,
then $[K:F]_s = [K:E]_s$.
It is a special case of `Field.lift_sepDegree_mul_lift_sepDegree_of_isAlgebraic`, and is an
intermediate result used to prove it. | true |
_private.Mathlib.Algebra.Group.Basic.0.add_zsmul_add.match_1_1 | Mathlib.Algebra.Group.Basic | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | null | false |
Set.unbounded_le_Ioi | Mathlib.Order.Bounded | ∀ {α : Type u_1} [inst : SemilatticeSup α] [NoMaxOrder α] (a : α), Set.Unbounded (fun x1 x2 => x1 ≤ x2) (Set.Ioi a) | null | true |
Std.DTreeMap.Internal.Impl.Const.minEntry?._proof_1 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : Type u_2}, WellFounded (invImage (fun x => x) sizeOfWFRel).1 | null | false |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.instEpiModuleCatH1π._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G),
CategoryTheory.Epi (groupHomology.H1π A) | null | false |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.card_nthRoots._simp_1_2 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {α : Type u_1} {s : Multiset α}, (s = 0) = ∀ (a : α), a ∉ s | null | false |
Std.DTreeMap.Raw.getKeyD_erase_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k fallback : α}, (t.erase k).getKeyD k fallback = fallback | null | true |
_private.Std.Data.DTreeMap.Internal.Queries.0.Std.DTreeMap.Internal.Impl.minEntryD.match_1.eq_1 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → (a : α) × β a → Sort u_3)
(fallback : (a : α) × β a) (h_1 : (fallback : (a : α) × β a) → motive Std.DTreeMap.Internal.Impl.leaf fallback)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
(r : Std.DTreeMap.Internal.Im... | null | true |
_private.Lean.Elab.Attributes.0.Lean.Elab.elabAttr._sparseCasesOn_7 | Lean.Elab.Attributes | {ε : Type u} →
{α : Type v} →
{motive : Except ε α → Sort u_1} →
(t : Except ε α) → ((a : α) → motive (Except.ok a)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
fwdDiff_addChar_eq | Mathlib.Algebra.Group.ForwardDiff | ∀ {M : Type u_3} {R : Type u_4} [inst : AddCommMonoid M] [inst_1 : Ring R] (φ : AddChar M R) (x h : M) (n : ℕ),
(fwdDiff h)^[n] (⇑φ) x = (φ h - 1) ^ n * φ x | null | true |
_private.Init.Data.Array.Lemmas.0.Array.back?_eq_some_iff._simp_1_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {as : List α} {xs : Array α}, (as.toArray = xs) = (as = xs.toList) | null | false |
summable_geometric_iff_norm_lt_one._simp_1 | Mathlib.Analysis.SpecificLimits.Normed | ∀ {K : Type u_4} [inst : NormedDivisionRing K] {ξ : K}, (Summable fun n => ξ ^ n) = (‖ξ‖ < 1) | null | false |
_private.Mathlib.Algebra.Lie.Basis.Base.0.LieAlgebra.Basis.root_mem_or_mem_neg._simp_1_6 | Mathlib.Algebra.Lie.Basis.Base | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {M : Type u_8} {N₂ : Type u_12} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommGroup N₂] [inst_4 : Module R₁ M] [inst_5 : Module R₂ N₂] {σ₁₂ : R₁ →+* R₂}
(f : M →ₛₗ[σ₁₂] N₂), -⇑f = ⇑(-f) | null | false |
_private.Init.Data.List.Find.0.List.finIdxOf?_eq_pmap_idxOf?._simp_1_10 | Init.Data.List.Find | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
SeminormFamily.basisSets_smul_right | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {R : Type u_1} {E : Type u_6} {ι : Type u_9} [inst : SeminormedRing R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
(p : SeminormFamily R E ι) (v : E), ∀ U ∈ p.basisSets, ∀ᶠ (x : R) in nhds 0, x • v ∈ U | null | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.Functor.0.CategoryTheory.Functor.map_opShiftFunctorEquivalence_counitIso_inv_app_unop._simp_1_2 | Mathlib.CategoryTheory.Triangulated.Opposite.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.unop f.unop = (CategoryTheory.CategoryStruct.comp f g).unop | null | false |
Function.Injective.addCommMonoidWithOne | Mathlib.Algebra.Ring.InjSurj | {R : Type u_1} →
{S : Type u_3} →
[inst : Zero S] →
[inst_1 : One S] →
[inst_2 : Add S] →
[inst_3 : SMul ℕ S] →
[inst_4 : NatCast S] →
[inst_5 : AddCommMonoidWithOne R] →
(f : S → R) →
Function.Injective f →
f ... | A type endowed with `0`, `1` and `+` is an additive commutative monoid with one, if it admits an
injective map that preserves `0`, `1` and `+` to an additive commutative monoid with one.
See note [reducible non-instances]. | true |
Std.Http.Body.Full.casesOn | Std.Http.Data.Body.Full | {motive : Std.Http.Body.Full → Sort u} →
(t : Std.Http.Body.Full) →
((data : ByteArray) → (state : Std.Mutex Std.Http.Body.Full.State✝) → motive { data := data, state := state }) →
motive t | null | false |
Lean.Widget.instToModuleUserWidgetDefinition._proof_1 | Lean.Widget.UserWidget | ∀ (uwd : Lean.Widget.UserWidgetDefinition), hash uwd.javascript = hash uwd.javascript | null | false |
CompactlySupportedContinuousMap.copy._proof_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β]
(f : CompactlySupportedContinuousMap α β) (f' : α → β), f' = ⇑f → HasCompactSupport f' | null | false |
MeasureTheory.VectorMeasure.instAddCommGroup._proof_1 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_2} [inst : AddCommGroup M] [inst_1 : TopologicalSpace M]
[inst_2 : IsTopologicalAddGroup M],
autoParam (∀ (a b : MeasureTheory.VectorMeasure α M), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
String.Slice.Pattern.Model.CharPred.revMatchAt?_eq | Init.Data.String.Lemmas.Pattern.Pred | ∀ {s : String.Slice} {pos : s.Pos} {p : Char → Bool},
String.Slice.Pattern.Model.revMatchAt? p pos =
if h₀ : ∃ (h : pos ≠ s.startPos), p ((pos.prev h).get ⋯) = true then some (pos.prev ⋯) else none | null | true |
Aesop.instInhabitedOptions.default | Aesop.Options.Public | Aesop.Options | null | true |
CategoryTheory.Subfunctor.epi_iff_range_eq_top | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor C (Type w)} (p : F' ⟶ F),
CategoryTheory.Epi p ↔ CategoryTheory.Subfunctor.range p = ⊤ | null | true |
instCompleteLinearOrderEReal._proof_13 | Mathlib.Data.EReal.Basic | ∀ (a b c : EReal), a \ b ≤ c ↔ a ≤ max b c | null | false |
IsApproximateSubgroup.casesOn | Mathlib.Combinatorics.Additive.ApproximateSubgroup | {G : Type u_1} →
[inst : Group G] →
{K : ℝ} →
{A : Set G} →
{motive : IsApproximateSubgroup K A → Sort u} →
(t : IsApproximateSubgroup K A) →
((one_mem : 1 ∈ A) → (inv_eq_self : A⁻¹ = A) → (sq_covBySMul : CovBySMul G K (A ^ 2) A) → motive ⋯) →
motive t | null | false |
Not.imp_symm | Mathlib.Basic.Logic.Basic | ∀ {a b : Prop}, (¬a → b) → ¬b → a | null | true |
Pi.infinite_of_left | Mathlib.Data.Fintype.Prod | ∀ {ι : Sort u_3} {π : ι → Type u_4} [∀ (i : ι), Nontrivial (π i)] [Infinite ι], Infinite ((i : ι) → π i) | null | true |
Std.Http.Protocol.H1.Reader.BodyState._sizeOf_inst | Std.Http.Protocol.H1.Reader | SizeOf Std.Http.Protocol.H1.Reader.BodyState | null | false |
RegularExpression.ctorElimType | Mathlib.Computability.RegularExpressions | {α : Type u} →
{motive : RegularExpression α → Sort u_1} → ℕ → Sort (max 1 u_1 (imax (u + 1) u_1) (imax (u + 1) (u + 1) u_1)) | null | false |
NumberField.ComplexEmbedding.lift.congr_simp | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ (K : Type u_1) [inst : Field K] {k : Type u_2} [inst_1 : Field k] [inst_2 : Algebra k K]
[inst_3 : Algebra.IsAlgebraic k K] (φ φ_1 : k →+* ℂ),
φ = φ_1 → NumberField.ComplexEmbedding.lift K φ = NumberField.ComplexEmbedding.lift K φ_1 | null | true |
map_comp_neg | Mathlib.Algebra.Group.Hom.Defs | ∀ {ι : Type u_1} {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : AddGroup G]
[inst_2 : SubtractionMonoid H] [AddMonoidHomClass F G H] (f : F) (g : ι → G), ⇑f ∘ (-g) = -⇑f ∘ g | null | true |
Lean.Parser.Term.letRecDecls.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
_private.Lean.Elab.PreDefinition.WF.Preprocess.0.Lean.Elab.WF.paramProj._sparseCasesOn_1 | Lean.Elab.PreDefinition.WF.Preprocess | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Lean.Meta.MonadSimp.mk.noConfusion | Lean.Meta.MonadSimp | {m : Type → Type} →
{P : Sort u} →
{withNewLemmas : {α : Type} → Array Lean.Expr → m α → m α} →
{dsimp : Lean.Expr → m Lean.Expr} →
{simp : Lean.Expr → m Lean.Meta.MonadSimp.Result} →
{withNewLemmas' : {α : Type} → Array Lean.Expr → m α → m α} →
{dsimp' : Lean.Expr → m Lean.Exp... | null | false |
Topology._aux_Mathlib_Topology_Defs_Filter___delab_app_Topology_nhdsGT_1 | Mathlib.Topology.Defs.Filter | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
Lean.Server.instRpcEncodableProd.match_1 | Lean.Server.Rpc.Basic | {α β : Type} → (motive : α × β → Sort u_1) → (x : α × β) → ((a : α) → (b : β) → motive (a, b)) → motive x | null | false |
Mathlib.Tactic.nlinarith | Mathlib.Tactic.Linarith.Frontend | Lean.ParserDescr | An extension of `linarith` with some preprocessing to allow it to solve some nonlinear arithmetic
problems. (Based on Coq's `nra` tactic.) See `linarith` for the available syntax of options,
which are inherited by `nlinarith`; that is, `nlinarith!` and `nlinarith only [h1, h2]` all work as
in `linarith`. The preprocess... | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.givenClause.parenthesizer_275 | Lean.Parser.Command | IO Unit | null | false |
CategoryTheory.GradedObject.ιMapObjOrZero_mapMap_assoc | Mathlib.CategoryTheory.GradedObject | ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{v_1, u_4} C]
{X Y : CategoryTheory.GradedObject I C} (φ : X ⟶ Y) (p : I → J) [inst_1 : X.HasMap p] [inst_2 : Y.HasMap p]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_4 : DecidableEq J] (i : I) (j : J) {Z : C}
(h : Y.mapOb... | null | true |
_private.Batteries.Data.PairingHeap.0.Batteries.PairingHeapImp.Heap.noSibling_tail?.match_1_2 | Batteries.Data.PairingHeap | ∀ {α : Type u_1}
(motive :
(s' : Batteries.PairingHeapImp.Heap α) →
(x : Option (α × Batteries.PairingHeapImp.Heap α)) → Option.map (fun x => x.2) x = some s' → Prop)
(s' : Batteries.PairingHeapImp.Heap α) (x : Option (α × Batteries.PairingHeapImp.Heap α))
(eq : Option.map (fun x => x.2) x = some s'),
... | null | false |
IsPrimitiveRoot.minpoly_dvd_pow_mod | Mathlib.RingTheory.RootsOfUnity.Minpoly | ∀ {n : ℕ} {K : Type u_1} [inst : CommRing K] {μ : K},
IsPrimitiveRoot μ n →
∀ [IsDomain K] [CharZero K] {p : ℕ} [hprime : Fact (Nat.Prime p)],
¬p ∣ n →
Polynomial.map (Int.castRingHom (ZMod p)) (minpoly ℤ μ) ∣
Polynomial.map (Int.castRingHom (ZMod p)) (minpoly ℤ (μ ^ p)) ^ p | Let `P` be the minimal polynomial of a root of unity `μ` and `Q` be the minimal polynomial of
`μ ^ p`, where `p` is a prime that does not divide `n`. Then `P` divides `Q ^ p` modulo `p`. | true |
Lean.Doc.Block.rec_7 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{motive_1 : Lean.Doc.Block i b → Sort u_1} →
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1... | null | false |
UInt8.toUInt16_eq_mod_256_iff | Init.Data.UInt.Lemmas | ∀ (a : UInt8) (b : UInt16), a.toUInt16 = b % 256 ↔ a = b.toUInt8 | null | true |
Nat.toArray_rco_succ_right_eq_push | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, m ≤ n → (m...n + 1).toArray = (m...n).toArray.push n | null | true |
_private.Init.Data.Vector.Lemmas.0.Vector.mem_flatMap.match_1_2 | Init.Data.Vector.Lemmas | ∀ {α : Type u_2} {β : Type u_1} {m n : ℕ} {f : α → Vector β m} {b : β} {xs : Vector α n}
(motive : (∃ xs_1, (∃ a ∈ xs, f a = xs_1) ∧ b ∈ xs_1) → Prop) (x : ∃ xs_1, (∃ a ∈ xs, f a = xs_1) ∧ b ∈ xs_1),
(∀ (a : α) (h₁ : a ∈ xs) (h₂ : b ∈ f a), motive ⋯) → motive x | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_le_ediv_iff_of_dvd_of_neg_of_pos._simp_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, a < b → (a = b) = False | null | false |
CategoryTheory.Grp.instFullMonForget₂Mon | Mathlib.CategoryTheory.Monoidal.Grp | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
(CategoryTheory.Grp.forget₂Mon C).Full | null | true |
CategoryTheory.Grothendieck.eqToHom_eq | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (hF : X = Y),
CategoryTheory.eqToHom hF = { base := CategoryTheory.eqToHom ⋯, fiber := CategoryTheory.eqToHom ⋯ } | null | true |
Nat.zero_dvd._simp_1 | Init.Data.Nat.Dvd | ∀ {n : ℕ}, (0 ∣ n) = (n = 0) | null | false |
CategoryTheory.Bicategory.InducedBicategory.forget_mapComp_inv | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b c : CategoryTheory.Bicategory.InducedBicategory C F} (f : a ⟶ b) (g : b ⟶ c),
(CategoryTheory.Bicategory.InducedBicategory.forget.mapComp f g).inv =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f.hom g.... | null | true |
CategoryTheory.MonoidalCategory.tensorLeftTensor_hom_app | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y Z : C),
(CategoryTheory.MonoidalCategory.tensorLeftTensor X Y).hom.app Z =
(CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom | null | true |
WeierstrassCurve.φ_four | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R),
W.φ 4 =
Polynomial.C Polynomial.X * Polynomial.C W.preΨ₄ ^ 2 * W.ψ₂ ^ 2 -
Polynomial.C W.preΨ₄ * W.ψ₂ ^ 4 * Polynomial.C W.Ψ₃ +
Polynomial.C W.Ψ₃ ^ 4 | null | true |
OrderMonoidHomClass.toOrderAddMonoidHom | Mathlib.Algebra.Order.Hom.Monoid | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : AddZeroClass α] →
[inst_3 : AddZeroClass β] →
[inst_4 : FunLike F α β] → [OrderHomClass F α β] → [AddMonoidHomClass F α β] → F → α →+o β | Turn an element of a type `F` satisfying `OrderHomClass F α β` and `AddMonoidHomClass F α β`
into an actual `OrderAddMonoidHom`.
This is declared as the default coercion from `F` to `α →+o β`. | true |
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.UniqueProds.toTwoUniqueProds_of_group._simp_1_3 | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | null | false |
Substring.Raw.Legacy.foldr | Batteries.Data.String.Legacy | {α : Type u} → (Char → α → α) → α → Substring.Raw → α | Folds a function over a substring from the right, accumulating a value starting with `init`. The
accumulated value is combined with each character in reverse order, using `f`.
This is an old implementation, preserved here for users of the lemmas in
`Batteries.Data.String.Lemmas`.
| true |
Fin.insertNthEquiv.eq_1 | Mathlib.MeasureTheory.Integral.Pi | ∀ {n : ℕ} (α : Fin (n + 1) → Type u) (p : Fin (n + 1)),
Fin.insertNthEquiv α p =
{ toFun := fun f => p.insertNth f.1 f.2, invFun := fun f => (f p, p.removeNth f), left_inv := ⋯, right_inv := ⋯ } | null | true |
CategoryTheory.Functor.WellOrderInductionData.Extension.match_1 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | {J : Type u_1} →
[inst : LinearOrder J] →
(i : J) →
(motive : { x // x ∈ Set.Iio i }ᵒᵖ → Sort u_2) →
(x : { x // x ∈ Set.Iio i }ᵒᵖ) → ((k : J) → (hk : k ∈ Set.Iio i) → motive (Opposite.op ⟨k, hk⟩)) → motive x | null | false |
AlgebraicGeometry.Scheme.Hom.connectedComponentsHomeomorph_apply | Mathlib.AlgebraicGeometry.Geometrically.Connected | ∀ {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) [inst : AlgebraicGeometry.GeometricallyConnected f] (hf : IsOpenMap ⇑f)
(a : ConnectedComponents ↥X),
(AlgebraicGeometry.Scheme.Hom.connectedComponentsHomeomorph f hf) a = ⋯.connectedComponentsMap a | null | true |
Lean.Meta.Grind.Arith.Linear.State._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.Linear.Types | SizeOf Lean.Meta.Grind.Arith.Linear.State | null | false |
CategoryTheory.Limits.FormalCoproduct.isoOfComponents_hom_φ | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.Limits.FormalCoproduct C} (e : X.I ≃ Y.I)
(h : (i : X.I) → X.obj i ≅ Y.obj (e i)) (i : X.I),
(CategoryTheory.Limits.FormalCoproduct.isoOfComponents e h).hom.φ i = (h i).hom | null | true |
ContinuousAlternatingMap.le_of_opNNNorm_le | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : Fintype ι] {f : E [⋀^ι]→L[𝕜] F} {C : NNReal},
‖f‖₊ ≤ C → ∀ (m : ι → E), ‖f m‖₊ ≤ C... | null | true |
Order.PFilter.principal_le_iff | Mathlib.Order.PFilter | ∀ {P : Type u_1} [inst : Preorder P] {x : P} {F : Order.PFilter P}, Order.PFilter.principal x ≤ F ↔ x ∈ F | null | true |
Ideal.smul_mem_pointwise_smul_iff | Mathlib.RingTheory.Ideal.Pointwise | ∀ {M : Type u_1} {R : Type u_3} [inst : Group M] [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] {a : M}
{S : Ideal R} {x : R}, a • x ∈ a • S ↔ x ∈ S | null | true |
Option.getD.eq_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (dflt x : α), (some x).getD dflt = x | null | true |
CategoryTheory.MonoOver.congr._proof_2 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C) {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (e : C ≌ D) (f : CategoryTheory.MonoOver (e.functor.obj X)),
CategoryTheory.Mono
((CategoryTheory.Over.post e.inverse).obj ((CategoryTheory.MonoOver.forget (e.functor.obj X)).obj... | null | false |
Lean.Meta.Grind.SplitSource.beta.sizeOf_spec | Lean.Meta.Tactic.Grind.Types | ∀ (e : Lean.Expr), sizeOf (Lean.Meta.Grind.SplitSource.beta e) = 1 + sizeOf e | null | true |
CategoryTheory.LaxFunctor.PseudoCore._sizeOf_1 | Mathlib.CategoryTheory.Bicategory.Functor.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F : CategoryTheory.LaxFunctor B C} → [SizeOf B] → [SizeOf C] → F.PseudoCore → ℕ | null | false |
MulActionHom | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} → (M → N) → (X : Type u_5) → [SMul M X] → (Y : Type u_6) → [SMul N Y] → Type (max u_5 u_6) | Equivariant functions :
When `φ : M → N` is a function, and types `X` and `Y` are endowed with actions of `M` and `N`,
a function `f : X → Y` is `φ`-equivariant if `f (m • x) = (φ m) • (f x)`. | true |
Function.Embedding.optionEmbeddingEquiv_apply_fst | Mathlib.Logic.Embedding.Set | ∀ (α : Type u_1) (β : Type u_2) (f : Option α ↪ β),
((Function.Embedding.optionEmbeddingEquiv α β) f).fst = Function.Embedding.some.trans f | null | true |
_private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.map_genWeightSpace_eq_of_injective._simp_1_1 | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : AddCommGroup M']
[inst_6 : Module R M'] [inst_7 : LieRingModule L M'] {f : M →ₗ⁅R,L⁆ M'} {N : LieSubmodule R L M} (m' : M'),
(m' ∈... | null | false |
Right.add_pos | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddRightStrictMono α],
0 < a → b < c → b < a + c | Assumes right covariance.
The lemma assuming left covariance is `Left.add_pos`. | true |
CategoryTheory.Limits.WalkingPair.equivBool._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.WalkingPair | ∀ (b : Bool),
(fun x =>
match x with
| CategoryTheory.Limits.WalkingPair.left => true
| CategoryTheory.Limits.WalkingPair.right => false)
((fun b => Bool.recOn b CategoryTheory.Limits.WalkingPair.right CategoryTheory.Limits.WalkingPair.left) b) =
b | null | false |
_private.Mathlib.Topology.Order.HullKernel.0.PrimitiveSpectrum.isTopologicalBasis_relativeLower._simp_1_3 | Mathlib.Topology.Order.HullKernel | ∀ {α : Type u} (a : α), {a}.Finite = True | null | false |
WeierstrassCurve.Affine.Point.sym2x_some_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap | ∀ {R : Type u_1} [inst : CommRing R] {W' : WeierstrassCurve.Affine R} {x y : R} (h : W'.Nonsingular x y),
(WeierstrassCurve.Affine.Point.some x y h).sym2x 0 = ![x, 1, 0] | null | true |
Std.DTreeMap.Const.get?_filter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{f : α → β → Bool} {k : α},
Std.DTreeMap.Const.get? (Std.DTreeMap.filter f t) k =
(Std.DTreeMap.Const.get? t k).pfilter fun x h' => f (t.getKey k ⋯) x | null | true |
MeasureTheory.MeasureSpace.noConfusionType | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | Sort u → {α : Type u_5} → MeasureTheory.MeasureSpace α → {α' : Type u_5} → MeasureTheory.MeasureSpace α' → Sort u | null | false |
CategoryTheory.FreeBicategory.bicategory._proof_9 | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u_1} [inst : Quiver B] (x x_1 x_2 x_3 : CategoryTheory.FreeBicategory B) (f : x ⟶ x_1) (g : x_1 ⟶ x_2)
(h : x_2 ⟶ x_3),
Quot.mk CategoryTheory.FreeBicategory.Rel
((CategoryTheory.FreeBicategory.Hom₂.associator f g h).vcomp
(CategoryTheory.FreeBicategory.Hom₂.associator_inv f g h)) =
Qu... | null | false |
QuadraticForm.tensorRId_toLinearEquiv | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct.Isometries | ∀ {R : Type uR} {M₁ : Type uM₁} [inst : CommRing R] [inst_1 : AddCommGroup M₁] [inst_2 : Module R M₁]
[inst_3 : Invertible 2] (Q₁ : QuadraticForm R M₁), Q₁.tensorRId.toLinearEquiv = TensorProduct.rid R M₁ | null | true |
InnerProductSpace.inner_gramSchmidtOrthonormalBasis_eq_zero | Mathlib.Analysis.InnerProductSpace.GramSchmidtOrtho | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_3} [inst_3 : LinearOrder ι] [inst_4 : LocallyFiniteOrderBot ι] [inst_5 : Fintype ι]
[inst_6 : FiniteDimensional 𝕜 E] (h : Module.finrank 𝕜 E = Fintype.card ι) {f : ι → E} {i : ι},
In... | null | true |
Lean.Meta.ApplyConfig.newGoals | Init.Meta.Defs | Lean.Meta.ApplyConfig → Lean.Meta.ApplyNewGoals | null | true |
_private.Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero.0.Submonoid.LocalizationMap.noZeroDivisors.match_1_1 | Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoidWithZero N]
(f : S.LocalizationMap N) (n : N) (motive : (∃ x, n * f ↑x.2 = f x.1) → Prop) (x : ∃ x, n * f ↑x.2 = f x.1),
(∀ (ms : M × ↥S) (eq : n * f ↑ms.2 = f ms.1), motive ⋯) → motive x | null | false |
CancelCommMonoid | Mathlib.Algebra.Group.Monoid | Type u_2 → Type u_2 | Commutative version of `CancelMonoid`. | true |
ModelWithCorners.isImmersionAtOfComplement | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_7} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {n : ℕ} {x : H},
Manifold.IsImmersionAtOfComplement PUnit.{u_15 + 1} I (modelWithCornersSelf 𝕜 E) (↑n) (↑I) x | Every `ModelWithCorners 𝕜 E H` is an immersion when viewed as a map `H → E`. | true |
CategoryTheory.SymmetricRelation.symmetry₂._autoParam | Mathlib.CategoryTheory.EquivalenceRelation | Lean.Syntax | null | false |
ConjAct.unitsMulSemiringAction._proof_2 | Mathlib.Algebra.Ring.Action.ConjAct | ∀ {R : Type u_1} [inst : Semiring R] (a : ConjAct Rˣ) (x y : R), a • (x + y) = a • x + a • y | null | false |
CategoryTheory.Triangulated.Octahedron'.triangleMorphism₂_hom₃ | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{X₁ X₂ X₃ Z₁₂ ... | null | true |
_private.Mathlib.NumberTheory.Modular.0.ModularGroup.abs_c_le_one._proof_1_2 | Mathlib.NumberTheory.Modular | (8 + 1).AtLeastTwo | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.eq_of_one_to_two.match_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (motive : Fin ({ len := 1 }.len + 1) → Prop) (i : Fin ({ len := 1 }.len + 1)),
(∀ (_ : Unit), motive 0) → (∀ (_ : Unit), motive 1) → motive i | null | false |
isNormableSpace_of_finiteDimensional | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : TopologicalSpace E] [IsTopologicalAddGroup E] [inst_5 : Module 𝕜 E] [ContinuousSMul 𝕜 E]
[FiniteDimensional 𝕜 E], IsNormableSpace 𝕜 E | A finite dimensional topological vector space over a complete normed field is normable.
Not registered as a global instance only for performance reasons. | true |
TopologicalSpace.CompactOpens.mk.inj | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_4} {inst : TopologicalSpace α} {toCompacts : TopologicalSpace.Compacts α}
{isOpen' : IsOpen toCompacts.carrier} {toCompacts_1 : TopologicalSpace.Compacts α}
{isOpen'_1 : IsOpen toCompacts_1.carrier},
{ toCompacts := toCompacts, isOpen' := isOpen' } = { toCompacts := toCompacts_1, isOpen' := isOpen'_... | null | true |
«term_→ₙ*_» | Mathlib.Algebra.Group.Hom.Defs | Lean.TrailingParserDescr | `M →ₙ* N` denotes the type of multiplication-preserving maps from `M` to `N`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.