name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Manifold.«term_≫_» | Mathlib.Geometry.Manifold.StructureGroupoid | Lean.TrailingParserDescr | Composing two partial equivs, by restricting to the maximal domain where their composition
is well defined.
Within the `Manifold` namespace, there is the notation `e ≫ f` for this.
| true |
CategoryTheory.Monoidal.InducingFunctorData._sizeOf_1 | Mathlib.CategoryTheory.Monoidal.Transport | {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.MonoidalCategoryStruct D} →
{F : CategoryTheory.Functor D C} →
[Si... | null | false |
_private.Mathlib.RingTheory.Idempotents.0.eq_of_isNilpotent_sub_of_isIdempotentElem_of_commute._simp_1_1 | Mathlib.RingTheory.Idempotents | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThree_of_FermatLastTheoremThreeGen | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ 3) [inst_1 : NumberField K]
[IsCyclotomicExtension {3} ℚ K], FermatLastTheoremForThreeGen✝ hζ → FermatLastTheoremFor 3 | To prove `FermatLastTheoremFor 3`, it is enough to prove `FermatLastTheoremForThreeGen`. | true |
Algebra.TensorProduct.piScalarRight_tmul | Mathlib.RingTheory.TensorProduct.Pi | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [inst_6 : IsScalarTower R S A] {ι : Type u_4}
[inst_7 : Fintype ι] [inst_8 : DecidableEq ι] (x : A) (y : ι → R),
(Algebra.Tens... | null | true |
AddSubgroup.nsmul_mem_of_index_ne_zero_of_dvd | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G},
H.index ≠ 0 → ∀ (a : G) {n : ℕ}, (∀ (m : ℕ), 0 < m → m ≤ H.index → m ∣ n) → n • a ∈ H | null | true |
Inclusion.HypothesisM.State.ctorIdx | Mathlib.Tactic.Inclusion.Core.Types | Inclusion.HypothesisM.State → ℕ | null | false |
Finpartition.rec | Mathlib.Order.Partition.Finpartition | {α : Type u_1} →
[inst : Lattice α] →
[inst_1 : OrderBot α] →
{a : α} →
{motive : Finpartition a → Sort u} →
((parts : Finset α) →
(supIndep : parts.SupIndep id) →
(sup_parts : parts.sup id = a) →
(bot_notMem : ⊥ ∉ parts) →
... | null | false |
Lean.StructureResolutionState.rec | Lean.Structure | {motive : Lean.StructureResolutionState → Sort u} →
((resolutions : Lean.PHashMap Lean.Name (Array Lean.Name)) → motive { resolutions := resolutions }) →
(t : Lean.StructureResolutionState) → motive t | null | false |
NFA.toεNFA | Mathlib.Computability.EpsilonNFA | {α : Type u} → {σ : Type v} → NFA α σ → εNFA α σ | `M.toεNFA` is an `εNFA` constructed from an `NFA` `M` by using the same start and accept
states and transition functions. | true |
_private.Mathlib.Order.Filter.Lift.0.Filter.HasBasis.lift._simp_1_1 | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop}, (∃ x, p x) = ∃ a b, p ⟨a, b⟩ | null | false |
SimpleGraph.Walk.IsCircuit.ne_bot | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, p.IsCircuit → G ≠ ⊥ | null | true |
Lean.DeprecatedModuleEntry.mk.injEq | Lean.DeprecatedModule | ∀ (message? since? message?_1 since?_1 : Option String),
({ message? := message?, since? := since? } = { message? := message?_1, since? := since?_1 }) =
(message? = message?_1 ∧ since? = since?_1) | null | true |
SetLike.delabSubtypeSetLike | Mathlib.Basic.SetLike.Basic | Lean.PrettyPrinter.Delaborator.Delab | For terms that match the `CoeSort` instance's body, pretty print as `↥S`
rather than as `{ x // x ∈ S }`. The discriminating feature is that membership
uses the `SetLike.instMembership` instance. | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.slice_inj._proof_1_2 | Init.Data.String.Basic | ∀ {s : String.Slice} {p₀ pos pos' : s.Pos},
p₀.offset.byteIdx ≤ pos.offset.byteIdx →
p₀.offset.byteIdx ≤ pos'.offset.byteIdx →
¬(pos.offset.byteIdx - p₀.offset.byteIdx = pos'.offset.byteIdx - p₀.offset.byteIdx ↔
pos.offset.byteIdx = pos'.offset.byteIdx) →
False | null | false |
_private.Init.Data.Option.Lemmas.0.Option.pfilter_eq_some_iff._simp_1_2 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o : Option α} {p : (a : α) → o = some a → Bool},
((o.pfilter p).isSome = true) = ∃ a, ∃ (ha : o = some a), p a ha = true | null | false |
Lean.Meta.CongrArgKind.casesOn | Lean.Meta.CongrTheorems | {motive : Lean.Meta.CongrArgKind → Sort u} →
(t : Lean.Meta.CongrArgKind) →
motive Lean.Meta.CongrArgKind.fixed →
motive Lean.Meta.CongrArgKind.fixedNoParam →
motive Lean.Meta.CongrArgKind.eq →
motive Lean.Meta.CongrArgKind.cast →
motive Lean.Meta.CongrArgKind.heq → motive Lean... | null | false |
TestFunction.instAddCommGroup._proof_13 | Mathlib.Analysis.Distribution.TestFunction | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], ContinuousConstSMul ℕ F | null | false |
CategoryTheory.EffectiveEpiFamily.fac | Mathlib.CategoryTheory.EffectiveEpi.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {B W : C} {α : Type u_2} (X : α → C)
(π : (a : α) → X a ⟶ B) [inst_1 : CategoryTheory.EffectiveEpiFamily X π] (e : (a : α) → X a ⟶ W)
(h :
∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
CategoryTheory.CategoryStruct.comp g₁ (π a₁) = Ca... | null | true |
Associates.prod_factors | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] [Nontrivial α]
(s : Associates.FactorSet α), s.prod.factors = s | null | true |
Lean.Widget.RpcEncodablePacket.range._@.Lean.Widget.InteractiveGoal.2553565095._hygCtx._hyg.1 | Lean.Widget.InteractiveGoal | Lean.Widget.RpcEncodablePacket✝ → Lean.Json | null | false |
MeasureTheory.L2.inner_indicatorConstLp_one_indicatorConstLp_one | Mathlib.MeasureTheory.Function.L2Space | ∀ {α : Type u_1} {𝕜 : Type u_4} [inst : RCLike 𝕜] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α}
(hs : MeasurableSet s) (ht : MeasurableSet t)
(hμs : autoParam (μ s ≠ ⊤) MeasureTheory.L2.inner_indicatorConstLp_one_indicatorConstLp_one._auto_1)
(hμt : autoParam (μ t ≠ ⊤) MeasureTheory.L2.inn... | The inner product in `L2` of indicators of two sets with finite measure
is the measure of the intersection. | true |
Fin.succAboveOrderEmb_toEmbedding | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} (p : Fin (n + 1)), p.succAboveOrderEmb.toEmbedding = p.succAboveEmb | null | true |
Matrix.IsLowerTriangular | Mathlib.LinearAlgebra.Matrix.Block | {m : Type u_2} → {R : Type v} → [Zero R] → [LT m] → Matrix m m R → Prop | `M` is lower triangular: entries above the diagonal vanish. | true |
tendsto_nhds_unique_dist | Mathlib.Topology.MetricSpace.Pseudo.Basic | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f : β → α} {l : Filter β} {x y : α} [l.NeBot],
Filter.Tendsto f l (nhds x) → Filter.Tendsto f l (nhds y) → dist x y = 0 | A weaker version of `tendsto_nhds_unique` for `PseudoMetricSpace`. | true |
Sublattice.instCompleteLattice._proof_7 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : Lattice α] (_S : Sublattice α) (_a : α), False → _a ∈ _S | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.toSubgraph_adj_penultimate._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} (w : G.Walk u v), 0 < w.length → w.length - 1 + 1 = w.length | null | false |
_private.Mathlib.Basic.ENNReal.BigOperators.0.ENNReal.ofReal_prod_of_nonneg._simp_1_1 | Mathlib.Basic.ENNReal.BigOperators | ∀ {p q : NNReal}, (↑p = ↑q) = (p = q) | null | false |
Vector.swapAt!_mk._proof_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α}, xs.size = n → ∀ {i : ℕ} {x : α}, (xs.swapAt! i x).2.size = n | null | false |
Subsemiring.coe_set_mk | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} [inst : NonAssocSemiring R] {toSubmonoid : Submonoid R}
(add_mem : ∀ {a b : R}, a ∈ toSubmonoid.carrier → b ∈ toSubmonoid.carrier → a + b ∈ toSubmonoid.carrier)
(zero_mem : 0 ∈ toSubmonoid.carrier),
↑{ toSubmonoid := toSubmonoid, add_mem' := add_mem, zero_mem' := zero_mem } = ↑toSubmonoid | null | true |
CommSemiring.directSumGCommSemiring | Mathlib.Algebra.DirectSum.Ring | (ι : Type u_1) →
{R : Type u_2} → [inst : AddCommMonoid ι] → [inst_1 : CommSemiring R] → DirectSum.GCommSemiring fun x => R | A direct sum of copies of a `CommSemiring` inherits the commutative multiplication structure. | true |
Lean.Doc.WithSyntax.rec | Lean.Elab.DocString | {α : Type u} →
{motive : Lean.Doc.WithSyntax α → Sort u_1} →
((val : α) → (stx : Lean.Syntax) → motive { val := val, stx := stx }) → (t : Lean.Doc.WithSyntax α) → motive t | null | false |
CategoryTheory.CostructuredArrow.map₂Iso_counitIso | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : D} {S : CategoryTheory.Functor C D} {A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {U : CategoryTheory.Functor A B} {V... | null | true |
String.Slice.Pattern.Model.IsRevMatch.casesOn | Init.Data.String.Lemmas.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.Model.PatternModel pat] →
{s : String.Slice} →
{startPos : s.Pos} →
{motive : String.Slice.Pattern.Model.IsRevMatch pat startPos → Sort u} →
(t : String.Slice.Pattern.Model.IsRevMatch pat startPos) →
((matches_... | null | false |
CartanMatrix.Realisation.pairing_reflection_left | Mathlib.LinearAlgebra.Matrix.Cartan.Realisation | ∀ {n : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype n] [inst_1 : DecidableEq n]
[inst_2 : CommRing R] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N] [inst_6 : Module R N]
(rl : CartanMatrix.Realisation n R M N) (i : n) (x : M) (y : N),
(rl.pairing ((rl.reflecti... | null | true |
FirstOrder.Language.Substructure.mem_top._simp_1 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] (x : M), (x ∈ ⊤) = True | null | false |
MeasureTheory.IntegrableAtFilter.neg | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {E : Type u_5} {mα : MeasurableSpace α} [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure α}
{l : Filter α} {f : α → E}, MeasureTheory.IntegrableAtFilter f l μ → MeasureTheory.IntegrableAtFilter (-f) l μ | null | true |
Affine.Simplex.median_eq_line_point_centroid | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {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] {n : ℕ} [inst_4 : NeZero n] [CharZero k] (s : Affine.Simplex k P n) (i : Fin (n + 1)),
s.median i = line[k, s.points i, s.centroid] | The median of a simplex is the line through the vertex and the centroid. | true |
CuspFormClass.exists_sum_range_norm_sq_qExpansion_coeff_le | Mathlib.NumberTheory.ModularForms.Bounds | ∀ {k : ℕ} {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.IsArithmetic] {F : Type u_2} [inst : FunLike F UpperHalfPlane ℂ]
[CuspFormClass F Γ ↑k] (f : F),
∃ C,
∀ (M : ℕ),
∑ n ∈ Finset.range M, ‖(PowerSeries.coeff n) (UpperHalfPlane.qExpansion Γ.strictWidthInfty ⇑f)‖ ^ 2 ≤ C * ↑M ^ k | **Mean-square bound** for q-expansion coefficients of a cusp form: the sum of the squared
norms of the first `M` coefficients is bounded by a constant multiple of `M ^ k`. | true |
Lean.Meta.TransparencyMode._sizeOf_inst | Init.MetaTypes | SizeOf Lean.Meta.TransparencyMode | null | false |
LinearMap.BilinForm.Isometry.mk.sizeOf_spec | Mathlib.LinearAlgebra.BilinearForm.Isometry | ∀ {R : Type u_1} {M₁ : Type u_3} {M₂ : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] {B₁ : LinearMap.BilinForm R M₁}
{B₂ : LinearMap.BilinForm R M₂} [inst_5 : SizeOf R] [inst_6 : SizeOf M₁] [inst_7 : SizeOf M₂]
(toLinearMap ... | null | true |
CategoryTheory.ObjectProperty.IsClosedUnderFiniteProducts.recOn | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P : CategoryTheory.ObjectProperty C} →
{motive : P.IsClosedUnderFiniteProducts → Sort u} →
(t : P.IsClosedUnderFiniteProducts) →
((isClosedUnderLimitsOfShape :
∀ (J : Type) [Finite J], P.IsClosedUnderLimitsOf... | null | false |
MeasureTheory.Measure.uniformOfFinset_apply_singleton | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_2} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {s : Finset α} (a : α),
(MeasureTheory.Measure.uniformOfFinset s) {a} = if a ∈ s then (↑s.card)⁻¹ else 0 | null | true |
PFun.bind_defined | Mathlib.Data.PFun | ∀ {α : Type u_7} {β γ : Type u_8} (p : Set α) {f : α →. β} {g : β → α →. γ},
p ⊆ f.Dom → (∀ (x : β), p ⊆ (g x).Dom) → p ⊆ (f >>= g).Dom | null | true |
Int.neg_le_iff | Init.Data.Int.Order | ∀ {x y : ℤ}, -x ≤ y ↔ -y ≤ x | null | true |
Set.instCompleteAtomicBooleanAlgebra._proof_1 | Mathlib.Data.Set.BooleanAlgebra | ∀ {α : Type u_1} (x : Set (Set α)), sSup x ∈ upperBounds x ∧ sSup x ∈ lowerBounds (upperBounds x) | null | false |
_private.Init.Data.Array.Erase.0.Array.eraseIdx_set_gt._proof_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i j : ℕ}, i < j → ∀ {w : j < xs.size}, ¬i < xs.size → False | null | false |
Real.Wallis.W._proof_2 | Mathlib.Analysis.Real.Pi.Wallis | (2 + 1).AtLeastTwo | null | false |
Filter.Eventually.self_of_nhdsWithin | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {p : α → Prop} {s : Set α} {x : α},
(∀ᶠ (y : α) in nhdsWithin x s, p y) → x ∈ s → p x | null | true |
CategoryTheory.ShortComplex.isLimitOfIsLimitπ._proof_6 | Mathlib.Algebra.Homology.ShortComplex.Limits | ∀ {J : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} (c : CategoryTheory.Limits.Cone F)
(h₂ : CategoryTheory.Limits.IsLimit (C... | null | false |
GaloisConnection.liftOrderTop._proof_1 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] [inst_2 : PartialOrder β] {u : α → β}
{l : β → α}, GaloisConnection l u → ∀ (x : β), x ≤ u ⊤ | null | false |
Lean.Parser.syntaxParser.parenthesizer | Lean.Parser.Syntax | optParam ℕ 0 → Lean.PrettyPrinter.Parenthesizer | null | true |
Filter.EventuallyConst.mul | Mathlib.Order.Filter.EventuallyConst | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} [inst : Mul β] {g : α → β},
Filter.EventuallyConst f l → Filter.EventuallyConst g l → Filter.EventuallyConst (f * g) l | null | true |
LieModuleHom.ker_id | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M], LieModuleHom.id.ker = ⊥ | null | true |
Std.Http.Status.methodNotAllowed.sizeOf_spec | Std.Http.Data.Status | sizeOf Std.Http.Status.methodNotAllowed = 1 | null | true |
RBTree.RBNode.Stream.foldr_cons | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} (t : RBTree.RBNode.Stream α) (l : List α),
RBTree.RBNode.Stream.foldr (fun x1 x2 => x1 :: x2) t l = t.toList ++ l | null | true |
RelEmbedding.ofOnFun | Mathlib.Order.RelIso.Basic | {α : Type u_1} → {β : Type u_2} → (r : β → β → Prop) → (f : α ↪ β) → Function.onFun r ⇑f ↪r r | For a `β`-relation `r`, an embedding `f : α ↪ β` induces a relation embedding from `r.onFun f`
to `r`. | true |
AlgHom.liftNormal | Mathlib.FieldTheory.Normal.Basic | {F : Type u_1} →
[inst : Field F] →
{K₁ : Type u_3} →
{K₂ : Type u_4} →
[inst_1 : Field K₁] →
[inst_2 : Field K₂] →
[inst_3 : Algebra F K₁] →
[inst_4 : Algebra F K₂] →
(K₁ →ₐ[F] K₂) →
(E : Type u_6) →
[inst_5 :... | If `E/Kᵢ/F` are towers of fields with `E/F` normal then we can lift
an algebra homomorphism `ϕ : K₁ →ₐ[F] K₂` to `ϕ.liftNormal E : E →ₐ[F] E`. | true |
toDual_intCast | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : IntCast R] (n : ℤ), OrderDual.toDual ↑n = ↑n | null | true |
Lean.Expr.getForallBodyMaxDepth | Lean.Expr | ℕ → Lean.Expr → Lean.Expr | null | true |
CoxeterSystem.map | Mathlib.GroupTheory.Coxeter.Basic | {B : Type u_1} →
{W : Type u_3} →
{H : Type u_4} →
[inst : Group W] → [inst_1 : Group H] → {M : CoxeterMatrix B} → CoxeterSystem M W → W ≃* H → CoxeterSystem M H | Push a Coxeter system through a group isomorphism. | true |
_private.Mathlib.Topology.Separation.SeparatedNhds.0.SeparatedNhds.union_left._simp_1_2 | Mathlib.Topology.Separation.SeparatedNhds | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] {a b c : α},
Disjoint (a ⊔ b) c = (Disjoint a c ∧ Disjoint b c) | null | false |
BitVec.eq_of_getElem_eq_iff | Init.Data.BitVec.Bootstrap | ∀ {n : ℕ} {x y : BitVec n}, x = y ↔ ∀ (i : ℕ) (hi : i < n), x[i] = y[i] | null | true |
String.dropEndWhile_append_takeEndWhile | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [String.Slice.Pattern.Model.PatternModel pat] [inst : String.Slice.Pattern.BackwardPattern pat]
[String.Slice.Pattern.LawfulBackwardPattern pat] {s : String},
(s.dropEndWhile pat).copy ++ (s.takeEndWhile pat).copy = s | null | true |
IsLinearSet.exists_fg_eq_subtypeVal | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M},
IsLinearSet s → ∃ P s', P.FG ∧ IsLinearSet s' ∧ s = Subtype.val '' s' | null | true |
sSup_sub | Mathlib.Algebra.Order.Group.Pointwise.CompleteLattice | ∀ {M : Type u_1} [inst : CompleteLattice M] [inst_1 : AddGroup M] [AddLeftMono M] [AddRightMono M] (s t : Set M),
sSup (s - t) = sSup s - sInf t | null | true |
_private.Init.Data.UInt.Bitwise.0.UInt16.and_eq_neg_one_iff._simp_1_2 | Init.Data.UInt.Bitwise | ∀ {w : ℕ} {x y : BitVec w}, (x &&& y = BitVec.allOnes w) = (x = BitVec.allOnes w ∧ y = BitVec.allOnes w) | null | false |
InfHom.withTop'._proof_1 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] [inst_2 : OrderTop β]
(f : InfHom α β) (a b : WithTop α), Option.elim (a ⊓ b) ⊤ ⇑f = Option.elim a ⊤ ⇑f ⊓ Option.elim b ⊤ ⇑f | null | false |
CompleteLat.Iso.mk._proof_1 | Mathlib.Order.Category.CompleteLat | ∀ {α β : CompleteLat} (e : ↑α ≃o ↑β),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ConcreteCategory.ofHom { toFun := ⇑e, map_sInf' := ⋯, map_sSup' := ⋯ })
(CategoryTheory.ConcreteCategory.ofHom { toFun := ⇑e.symm, map_sInf' := ⋯, map_sSup' := ⋯ }) =
CategoryTheory.CategoryStruct.id α | null | false |
Lean.ExceptToTraceResult.mk._flat_ctor | Lean.Util.Trace | {ε α : Type} → (Except ε α → Lean.TraceResult) → Lean.ExceptToTraceResult ε α | null | false |
_private.Mathlib.Tactic.NormNum.NatFactorial.0.Mathlib.Meta.NormNum.evalNatAscFactorial._proof_1 | Mathlib.Tactic.NormNum.NatFactorial | ∀ {u : Lean.Level} {α : Q(Type u)} (e : Q(«$α»)) (x y : Q(ℕ)), «$e» =Q «$x».ascFactorial «$y» | null | false |
Std.Http.Method._sizeOf_inst | Std.Http.Data.Method | SizeOf Std.Http.Method | null | false |
Matrix.entryAddMonoidHom._proof_2 | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_1} {n : Type u_2} (α : Type u_3) [inst : AddZeroClass α] (i : m) (j : n) (x x_1 : Matrix m n α),
(x + x_1) i j = (x + x_1) i j | null | false |
Complex.abs_re_eq_norm._simp_1 | Mathlib.Analysis.Complex.Norm | ∀ {z : ℂ}, (|z.re| = ‖z‖) = (z.im = 0) | null | false |
List.kextract._f | Mathlib.Data.List.Sigma | {α : Type u} →
{β : α → Type v} → [DecidableEq α] → (a : α) → (x : List (Sigma β)) → List.below x → Option (β a) × List (Sigma β) | null | false |
_private.Init.Data.UInt.Lemmas.0.UInt8.toBitVec_max._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a ≤ b) = (a.toBitVec ≤ b.toBitVec) | null | false |
Vector.getElem?_setIfInBounds_self | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} {xs : Vector α n} {x : α}, (xs.setIfInBounds i x)[i]? = if i < n then some x else none | null | true |
Mathlib.Tactic.IntervalCases.Methods.noConfusion | Mathlib.Tactic.IntervalCases | {P : Sort u} →
{t t' : Mathlib.Tactic.IntervalCases.Methods} → t = t' → Mathlib.Tactic.IntervalCases.Methods.noConfusionType P t t' | null | false |
Finset.sum_sq_le_sq_sum_of_nonneg | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] {f : ι → R}
{s : Finset ι}, (∀ i ∈ s, 0 ≤ f i) → ∑ i ∈ s, f i ^ 2 ≤ (∑ i ∈ s, f i) ^ 2 | null | true |
«_aux_Mathlib_Order_OrderDual___macroRules_term_ᵒᵈ_1» | Mathlib.Order.OrderDual | Lean.Macro | null | false |
_private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.lTensorKerIncl | Mathlib.RingTheory.AdicCompletion.AsTensorProduct | {R : Type u} →
[inst : CommRing R] →
(I : Ideal R) →
(M : Type u) →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{ι : Type} →
(f : (ι → R) →ₗ[R] M) →
TensorProduct R (AdicCompletion I R) ↥f.ker →ₗ[AdicCompletion I R]
Tensor... | The first horizontal arrow in the top row. | true |
HomotopicalAlgebra.FibrantObject.toHoCat | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
CategoryTheory.Functor (HomotopicalAlgebra.FibrantObject C) (HomotopicalAlgebra.FibrantObject.HoCat C) | The quotient functor from the category of fibrant objects to its
homotopy category. | true |
_private.Mathlib.Tactic.Algebra.Basic.0.Mathlib.Tactic.Algebra.RingCompute.cast.match_1 | Mathlib.Tactic.Algebra.Basic | {u : Lean.Level} →
{R : Q(Type u)} →
{sR : Q(CommSemiring «$R»)} →
(r : Q(«$R»)) →
(motive :
(_r'' : Q(«$R»)) →
Mathlib.Tactic.Ring.Common.ExSum Mathlib.Tactic.Ring.RatCoeff sR _r'' → Q(«$r» = «$_r''») → Sort u_1) →
(_r'' : Q(«$R»)) →
(vr : Mathlib.Tac... | null | false |
AddSubmonoid.coe_neg | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (S : AddSubmonoid G), ↑(-S) = -↑S | null | true |
GradedMonoid.GOne.mk._flat_ctor | Mathlib.Algebra.GradedMonoid | {ι : Type u_1} → {A : ι → Type u_2} → [inst : Zero ι] → A 0 → GradedMonoid.GOne A | null | false |
ContinuousMap.curry_inv_apply | Mathlib.Topology.ContinuousMap.Algebra | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_4} {Z : Type u_5} [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : Inv Z] [inst_4 : ContinuousInv Z] (f : C(X × Y, Z)) (x : X),
f⁻¹.curry x = (f.curry x)⁻¹ | null | true |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.hasCoeS.match_1 | Mathlib.Tactic.FBinop | (motive : Lean.LOption Lean.Expr → Sort u_1) →
(__do_lift : Lean.LOption Lean.Expr) →
((a : Lean.Expr) → motive (Lean.LOption.some a)) →
(Unit → motive Lean.LOption.none) → (Unit → motive Lean.LOption.undef) → motive __do_lift | null | false |
Set.mem_sigma_iff | Mathlib.Data.Set.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {x : (i : ι) × α i},
x ∈ s.sigma t ↔ x.fst ∈ s ∧ x.snd ∈ t x.fst | null | true |
IsTopologicalGroup.leftUniformSpace.congr_simp | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalGroup G],
IsTopologicalGroup.leftUniformSpace G = IsTopologicalGroup.leftUniformSpace G | null | true |
_private.Mathlib.Data.Nat.Totient.0.Nat.totient_pos._simp_1_1 | Mathlib.Data.Nat.Totient | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
HahnSeries.embDomain_notin_image_support | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : PartialOrder Γ']
{f : Γ ↪o Γ'} {x : HahnSeries Γ R} {b : Γ'}, b ∉ ⇑f '' x.support → (HahnSeries.embDomain f x).coeff b = 0 | null | true |
_private.Mathlib.GroupTheory.CoprodI.0.Monoid.CoprodI.Word.equivPairAux._proof_2 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : (i : ι) → DecidableEq (M i)] (i : ι),
Monoid.CoprodI.Word.rcons { head := 1, tail := Monoid.CoprodI.Word.empty, fstIdx_ne := ⋯ } = Monoid.CoprodI.Word.empty | null | false |
CategoryTheory.Comma.initial_fst | Mathlib.CategoryTheory.Comma.Final | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) [CategoryTheory.IsCofiltered A] [CategoryTheory.IsCofiltered B] [L.Ini... | Let `A` and `B` be cofiltered categories, `L : A ⥤ T` be initial and `R : B ⥤ T`. Then, the
projection `fst L R : Comma L R ⥤ A` is initial. | true |
CategoryTheory.Functor.Final.coconesEquiv._proof_6 | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u_2}
[inst_3 : CategoryTheory.Category.{u_1, u_2} E] (G : CategoryTheory.Functor D E) (c : CategoryTheory.Limits.Cocone G)
(j ... | null | false |
_private.Lean.Meta.Check.0.Lean.Meta.addPPExplicitToExposeDiff.visit._sparseCasesOn_14 | Lean.Meta.Check | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 1056 t.ctorIdx → motive t) → motive t | null | false |
QuasiErgodic.eq_const_of_compQuasiMeasurePreserving_eq | Mathlib.Dynamics.Ergodic.Function | ∀ {α : Type u_1} {X : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace X]
[TopologicalSpace.MetrizableSpace X] [Nonempty X] {f : α → α} (h : QuasiErgodic f μ) {g : α →ₘ[μ] X},
g.compQuasiMeasurePreserving f ⋯ = g → ∃ c, g = MeasureTheory.AEEqFun.const α c | null | true |
instSemilatticeSupSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_6 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommSemiring R] (a b : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }),
b ≤ ⟨((↑a).1 + (↑a).2 * (↑b).1, (↑a).2 * (↑b).2), ⋯⟩ | null | false |
OrderDual.instLocallyFiniteOrderBot | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → [inst : Preorder α] → [LocallyFiniteOrderTop α] → LocallyFiniteOrderBot αᵒᵈ | Note we define `Iic (toDual a)` as `Ici a` (which has type `Finset α` not `Finset αᵒᵈ`!)
instead of `(Ici a).map toDual.toEmbedding` as this means the following is defeq:
```
lemma this : (Iic (toDual (toDual a)) :) = (Iic a :) := rfl
```
| true |
MeasureTheory.prob_compl_eq_zero_iff₀ | Mathlib.MeasureTheory.Measure.Typeclasses.Probability | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}
[MeasureTheory.IsProbabilityMeasure μ], MeasureTheory.NullMeasurableSet s μ → (μ sᶜ = 0 ↔ μ s = 1) | null | true |
_private.Mathlib.Logic.Function.Iterate.0.Function.iterate_invariant.match_1_1 | Mathlib.Logic.Function.Iterate | ∀ (motive : ℕ → Prop) (n : ℕ), (∀ (_ : Unit), motive 0) → (∀ (m : ℕ), motive m.succ) → motive n | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.