name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Lsp.DocumentSymbolAux.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{Self : Type} →
{t : Lean.Lsp.DocumentSymbolAux Self} →
{Self' : Type} →
{t' : Lean.Lsp.DocumentSymbolAux Self'} →
Self = Self' → t ≍ t' → Lean.Lsp.DocumentSymbolAux.noConfusionType P t t' | null | false |
Ideal.IsPrime.mem_or_mem_of_mul_eq_zero | Mathlib.RingTheory.Ideal.Prime | ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, I.IsPrime → ∀ {x y : α}, x * y = 0 → x ∈ I ∨ y ∈ I | null | true |
CuspForm.hasAdd | Mathlib.NumberTheory.ModularForms.Basic | {Γ : Subgroup (GL (Fin 2) ℝ)} → {k : ℤ} → Add (CuspForm Γ k) | null | true |
Std.Time.Week.instDecidableLtOffset._aux_1 | Std.Time.Date.Unit.Week | {x y : Std.Time.Week.Offset} → Decidable (x < y) | null | false |
Finset.singleton_sups_singleton | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeSup α] {a b : α}, {a} ⊻ {b} = {a ⊔ b} | null | true |
BitVec.mulRec._unsafe_rec | Init.Data.BitVec.Bitblast | {w : ℕ} → BitVec w → BitVec w → ℕ → BitVec w | null | false |
CoeTC | Init.Coe | Sort u → Sort v → Sort (max (max 1 u) v) | Auxiliary class implementing `Coe*`.
Users should generally not implement this directly.
| true |
ProbabilityTheory.Kernel.compProd_fst_borelMarkovFromReal | Mathlib.Probability.Kernel.Disintegration.StandardBorel | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω] [inst_1 : Nonempty Ω] (κ : ProbabilityTheory.Kernel α (β × Ω))
[ProbabilityTheory.IsSFiniteKernel κ] (η : ProbabilityTheory.Kernel (α × β) ℝ) [ProbabilityTheory.IsS... | For `κ' := map κ (Prod.map (id : β → β) e)`, the hypothesis `hη` is `fst κ' ⊗ₖ η = κ'`.
With that hypothesis, `fst κ ⊗ₖ borelMarkovFromReal κ η = κ`. | true |
CategoryTheory.MorphismProperty.IsStableUnderComposition.unop | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty Cᵒᵖ}
[P.IsStableUnderComposition], P.unop.IsStableUnderComposition | null | true |
SimpleGraph.Walk.ofDarts._proof_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} (d₂ : G.Dart) (l : List G.Dart), d₂ :: l ≠ [] | null | false |
Std.DTreeMap.Internal.Impl.balancedAtRoot_zero_iff' | Std.Data.DTreeMap.Internal.Balanced | ∀ {n : ℕ}, Std.DTreeMap.Internal.Impl.BalancedAtRoot n 0 ↔ n ≤ 1 | null | true |
LinearOrderedAddCommGroupWithTop.add_le_add_right._inherited_default | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_3} (zero : α) (add : α → α → α) (add_assoc : ∀ (a b c : α), a + b + c = a + (b + c))
(zero_add : ∀ (a : α), 0 + a = a) (add_zero : ∀ (a : α), a + 0 = a) (nsmul : ℕ → α → α)
(nsmul_zero : ∀ (x : α), 0 • x = 0) (nsmul_succ : ∀ (n : ℕ) (x : α), (n + 1) • x = n • x + x)
(add_comm : ∀ (a b : α), a + b = ... | null | false |
Submodule.one_le_finrank_iff._simp_1 | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsDomain R]
[Module.IsTorsionFree R M] [StrongRankCondition R] {S : Submodule R M} [Module.Finite R ↥S],
(1 ≤ Module.finrank R ↥S) = (S ≠ ⊥) | null | false |
Prod.mk_eq_zero._simp_1 | Mathlib.Algebra.Notation.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : Zero M] [inst_1 : Zero N] {x : M} {y : N}, ((x, y) = 0) = (x = 0 ∧ y = 0) | null | false |
MeasureTheory.ofReal_setIntegral_one_of_measure_ne_top._auto_1 | Mathlib.MeasureTheory.Integral.Bochner.Set | Lean.Syntax | null | false |
HurwitzZeta.hurwitzZetaEven_def_of_ne_or_ne | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ {a : UnitAddCircle} {s : ℂ},
a ≠ 0 ∨ s ≠ 0 → HurwitzZeta.hurwitzZetaEven a s = HurwitzZeta.completedHurwitzZetaEven a s / s.Gammaℝ | null | true |
Computation.bind.eq_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} (c : Computation α) (f : α → Computation β),
c.bind f = Computation.corec (Computation.Bind.f f) (Sum.inl c) | null | true |
ContinuousLinearMap.coprodEquiv | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.PiProd | {R : Type u_1} →
{S : Type u_2} →
{M : Type u_3} →
{M₁ : Type u_5} →
{M₂ : Type u_6} →
[inst : Semiring R] →
[inst_1 : TopologicalSpace M] →
[inst_2 : TopologicalSpace M₁] →
[inst_3 : TopologicalSpace M₂] →
[inst_4 : AddCommMonoid... | Taking the product of two maps with the same codomain is equivalent to taking the product of
their domains.
See note [bundled maps over different rings] for why separate `R` and `S` semirings are used.
See `ContinuousLinearMap.coprodEquivL` for the `ContinuousLinearEquiv` version.
| true |
Algebra.ofId.eq_1 | Mathlib.Algebra.Central.Basic | ∀ (R : Type u) (A : Type v) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
Algebra.ofId R A = { toRingHom := algebraMap R A, commutes' := ⋯ } | null | true |
CategoryTheory.constantSheafAdj_counit_app | Mathlib.CategoryTheory.Sites.ConstantSheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
(D : Type u_2) [inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.HasWeakSheafify J D] {T : C}
(hT : CategoryTheory.Limits.IsTerminal T) (X : CategoryTheory.Sheaf J D),
(CategoryTheory.... | null | true |
MulOpposite.instAddCommGroup._proof_6 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : AddCommGroup α] (x : αᵐᵒᵖ) (x_1 : ℤ), MulOpposite.unop (x_1 • x) = MulOpposite.unop (x_1 • x) | null | false |
Std.Time.TimeZone.instReprUTLocal.repr | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.UTLocal → ℕ → Std.Format | null | true |
exteriorPower.pairingDual_apply_apply_eq_one_zero | Mathlib.LinearAlgebra.ExteriorPower.Pairing | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {ι : Type u_3}
[inst_3 : LinearOrder ι] (x : ι → M) (f : ι → Module.Dual R M),
(∀ ⦃i j : ι⦄, i ≠ j → (f i) (x j) = 0) →
∀ (n : ℕ) (a b : Fin n ↪o ι),
a ≠ b →
((exteriorPower.pairingDual R M n) ((ext... | null | true |
_private.Mathlib.Basic.Logic.Basic.0.dite_ne_left_iff._proof_1_1 | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} {P : Prop} [inst : Decidable P] {a : α} {B : ¬P → α}, ¬dite P (fun x => a) B = a ↔ ∃ (h : ¬P), ¬a = B h | null | false |
DFinsupp.support_rangeIcc_subset | Mathlib.Data.DFinsupp.Interval | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[inst_2 : (i : ι) → LocallyFiniteOrder (α i)] {f g : Π₀ (i : ι), α i} [inst_3 : DecidableEq ι]
[inst_4 : (i : ι) → DecidableEq (α i)], (f.rangeIcc g).support ⊆ f.support ∪ g.support | null | true |
_private.Lean.Meta.Tactic.Apply.0.Lean.Meta.reorderGoals | Lean.Meta.Tactic.Apply | Array Lean.Expr → Lean.Meta.ApplyNewGoals → Lean.MetaM (List Lean.MVarId) | null | true |
PeriodPair.instDiscreteTopologySubtypeComplexMemSubmoduleIntLattice | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), DiscreteTopology ↥L.lattice | null | true |
CategoryTheory.Functor.relativelyRepresentable.lift'.congr_simp | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {Y : D} {b : C} {f' : F.obj b ⟶ Y} (hf' : F.relativelyRepresentable f') {a : C}
{g : F.obj a ⟶ Y} {c : C} (i i_1 : c ⟶ b) (e_i : i = i_1) (h h_1 : c ⟶ a) (e_h : h ... | null | true |
MeasureTheory.isMulLeftInvariant_map_mul_right | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Semigroup G] [MeasurableMul G] {μ : MeasureTheory.Measure G}
[μ.IsMulLeftInvariant] (g : G), (MeasureTheory.Measure.map (fun x => x * g) μ).IsMulLeftInvariant | The image of a left invariant measure under right multiplication is left invariant. | true |
TopologicalSpace.Compacts.compactsInsideOfOpenNhds | Mathlib.Topology.Sets.Compacts | {α : Type u_1} →
[inst : TopologicalSpace α] → {K : TopologicalSpace.Compacts α} → (U : ↑K.openNhds) → ↑(↑U).compactsInside | For `U` an open neighbourhood of `K`, `K` has a structure of compact inside `U` | true |
Subfield.relrank_comap_comap_eq_relrank_inf | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A B : Subfield E) {L : Type v} [inst_1 : Field L] (f : L →+* E),
(Subfield.comap f A).relrank (Subfield.comap f B) = A.relrank (B ⊓ f.fieldRange) | null | true |
Topology.IsLowerSet.specializes_iff_le | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLowerSet α] {a b : α}, a ⤳ b ↔ a ≤ b | null | true |
Std.TreeMap.Raw.instSliceableRiiSlice._auto_1 | Std.Data.TreeMap.Raw.Slice | Lean.Syntax | null | false |
iSup_prod | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CompleteLattice α] {f : β × γ → α}, ⨆ x, f x = ⨆ i, ⨆ j, f (i, j) | null | true |
Int16.ofIntLE_int8ToInt | Init.Data.SInt.Lemmas | ∀ (x : Int8), Int16.ofIntLE x.toInt ⋯ ⋯ = x.toInt16 | null | true |
Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr.p | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr → Lean.Grind.CommRing.Poly | null | true |
BitVec.smtUDiv | Init.Data.BitVec.Basic | {n : ℕ} → BitVec n → BitVec n → BitVec n | Unsigned division of bitvectors using the
[SMT-LIB convention](http://smtlib.cs.uiowa.edu/theories-FixedSizeBitVectors.shtml),
where division by zero returns `BitVector.allOnes n`.
SMT-LIB name: `bvudiv`.
| true |
ENNReal.pow_lt_pow_left_iff | Mathlib.Basic.ENNReal.Operations | ∀ {a b : ENNReal} {n : ℕ}, n ≠ 0 → (a ^ n < b ^ n ↔ a < b) | null | true |
CategoryTheory.cechNerveTerminalFrom | Mathlib.AlgebraicTopology.CechNerve | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasFiniteProducts C] → C → CategoryTheory.SimplicialObject C | Given an object `X : C`, the natural simplicial object sending `⦋n⦌` to `Xⁿ⁺¹`. | true |
LaurentSeries.LaurentSeriesPkg._proof_2 | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_1) [inst : Field K], T0Space (LaurentSeries K) | null | false |
CategoryTheory.Lax.LaxTrans.isoMk._proof_3 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u_5} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} (app : (a : B) → η.app a ≅ θ.app a),
(∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (app a).hom ... | null | false |
List.foldr_push_eq_append' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {l : List α} {xs : Array α}, List.foldr (fun x xs => xs.push x) xs l = xs ++ l.reverse.toArray | Variant of `List.foldr_push_eq_append` specialized to `f = id`. | true |
Lean.Parser.commandUnseal__ | Init.Notation | Lean.ParserDescr | The `unseal foo` command ensures that the definition of `foo` is unsealed, meaning it is marked as `[semireducible]`, the
default reducibility setting. This command is useful when you need to allow some level of reduction of `foo` in proofs.
Functionally, `unseal foo` is equivalent to `attribute [local semireducible] ... | true |
CategoryTheory.WithInitial.instUniqueHomStar._proof_1 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : CategoryTheory.WithInitial C}
(a : CategoryTheory.WithInitial.star ⟶ X),
a =
match X with
| CategoryTheory.WithInitial.of _x => PUnit.unit
| CategoryTheory.WithInitial.star => PUnit.unit | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int32.reduceSub._regBuiltin.Int32.reduceSub.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3685453738._hygCtx._hyg.112 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
List.take_eq_dropLast | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {l : List α} {i : ℕ}, i + 1 = l.length → List.take i l = l.dropLast | null | true |
_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.SimpleGroundValue.uint32 | Lean.Compiler.LCNF.SimpleGroundExpr | UInt32 → Lean.Compiler.LCNF.SimpleGroundValue✝ | null | true |
Polynomial.Splits.coeff_zero_eq_prod_roots_of_monic | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R],
f.Splits → f.Monic → f.coeff 0 = (-1) ^ f.natDegree * f.roots.prod | If `f` is a monic polynomial that splits, then `coeff f 0` equals the product of the roots. | true |
addIrreducible_or_factor | Mathlib.Algebra.Group.Irreducible.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {p : M},
¬IsAddUnit p → AddIrreducible p ∨ ∃ a b, ¬IsAddUnit a ∧ ¬IsAddUnit b ∧ p = a + b | null | true |
NNRat.instMetricSpace._proof_22 | Mathlib.Topology.Instances.Rat | NNRat.instMetricSpace._aux_20 ≤ Filter.cofinite | null | false |
AddActionHom.casesOn | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_8} →
{N : Type u_9} →
{φ : M → N} →
{X : Type u_10} →
[inst : VAdd M X] →
{Y : Type u_11} →
[inst_1 : VAdd N Y] →
{motive : (X →ₑ[φ] Y) → Sort u} →
(t : X →ₑ[φ] Y) →
((toFun : X → Y) →
(map_vadd' ... | null | false |
NonUnitalSubsemiring.map_map | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} {T : Type w} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
[inst_2 : NonUnitalNonAssocSemiring T] (s : NonUnitalSubsemiring R) (g : S →ₙ+* T) (f : R →ₙ+* S),
NonUnitalSubsemiring.map g (NonUnitalSubsemiring.map f s) = NonUnitalSubsemiring.map (g.comp f) s | null | true |
ChainComplex.mk_congr_succ_X₃ | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(succ :
(S : CategoryTheory.ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ ⟶ S.X₁) ×' CategoryTheory.CategoryStruct.comp d₂ S.f = 0)
{S S' : CategoryTheory.ShortComplex V}, S = S' → (succ S).fst = (succ S').fst | null | true |
ZeroAtInftyContinuousMap.instStarRing | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : NonUnitalSemiring β] →
[inst_2 : StarRing β] →
[inst_3 : TopologicalSpace β] →
[ContinuousStar β] → [inst_5 : IsTopologicalSemiring β] → StarRing (ZeroAtInftyContinuousMap α β) | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform._proof_8 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_5} {B : Type u_6} {C : Type u_7} [inst : CategoryTheory.Category.{u_1, u_5} A]
[inst_1 : CategoryTheory.Category.{u_2, u_6} B] [inst_2 : CategoryTheory.Category.{u_3, u_7} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u_11} {B₁ : Type u_14} {C₁ : Type u_12}
[inst_3 ... | null | false |
_private.Mathlib.RingTheory.Algebraic.StronglyTranscendental.0.IsStronglyTranscendental.of_isLocalization._simp_1_3 | Mathlib.RingTheory.Algebraic.StronglyTranscendental | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A],
(algebraMap S A).comp (algebraMap R S) = algebraMap R A | null | false |
OpenAddSubgroup.mk.inj | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} {inst : AddGroup G} {inst_1 : TopologicalSpace G} {toAddSubgroup : AddSubgroup G}
{isOpen' : IsOpen toAddSubgroup.carrier} {toAddSubgroup_1 : AddSubgroup G}
{isOpen'_1 : IsOpen toAddSubgroup_1.carrier},
{ toAddSubgroup := toAddSubgroup, isOpen' := isOpen' } = { toAddSubgroup := toAddSubgroup_1, i... | null | true |
MultilinearMap.dfinsuppFamily_smul | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {ι : Type uι} {κ : ι → Type uκ} {S : Type uS} {R : Type uR} {M : (i : ι) → κ i → Type uM}
{N : ((i : ι) → κ i) → Type uN} [inst : DecidableEq ι] [inst_1 : Fintype ι] [inst_2 : Semiring R]
[inst_3 : (i : ι) → (k : κ i) → AddCommMonoid (M i k)] [inst_4 : (p : (i : ι) → κ i) → AddCommMonoid (N p)]
[inst_5 : (i : ι... | null | true |
UInt64.ofNatLT_uInt8ToNat._proof_1 | Init.Data.UInt.Lemmas | 2 ^ 8 < UInt64.size | null | false |
Finset.forall_mem_map | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {p : (a : β) → a ∈ Finset.map f s → Prop},
(∀ (y : β) (H : y ∈ Finset.map f s), p y H) ↔ ∀ (x : α) (H : x ∈ s), p (f x) ⋯ | null | true |
CategoryTheory.PreOneHypercover.Homotopy.H | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} →
{F : CategoryTheory.PreOneHypercover S} →
{f g : E.Hom F} → CategoryTheory.PreOneHypercover.Homotopy f g → (i : E.I₀) → F.I₁ (f.s₀ i) (g.s₀ i) | The index map sending `i : E.I₀` to `a` above `(f(i), g(i))`. | true |
_private.Mathlib.Combinatorics.SimpleGraph.CycleGraph.0.SimpleGraph.cycleGraph_isContained_iff._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.CycleGraph | ∀ {n : ℕ}, 2 < n → n - 3 + 3 = n | null | false |
_private.Mathlib.Combinatorics.Colex.0.Finset.Colex.toColex_le_toColex_iff_max'_mem.match_1_1 | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : LinearOrder α] {s t : Finset α} (m : α)
(motive : (∃ b ∈ ofColex (toColex t), b ∉ ofColex (toColex s) ∧ m ≤ b) → Prop)
(x : ∃ b ∈ ofColex (toColex t), b ∉ ofColex (toColex s) ∧ m ≤ b),
(∀ (b : α) (hbt : b ∈ ofColex (toColex t)) (hbs : b ∉ ofColex (toColex s)) (hmb : m ≤ b), motive ⋯) → mo... | null | false |
Simplicial.«_aux_Mathlib_AlgebraicTopology_SimplexCategory_Defs___macroRules_Simplicial_term⦋_⦌_1» | Mathlib.AlgebraicTopology.SimplexCategory.Defs | Lean.Macro | null | false |
AddSubgroup.isFiniteRelIndex_iff_finiteIndex | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G}, H.IsFiniteRelIndex K ↔ (H.addSubgroupOf K).FiniteIndex | null | true |
AddSubgroup.closure_add_image_eq_top | Mathlib.GroupTheory.Schreier | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} {R S : Set G} (hR : AddSubgroup.IsComplement (↑H) R),
0 ∈ R → AddSubgroup.closure S = ⊤ → AddSubgroup.closure ((fun g => ⟨g + -↑(hR.toRightFun g), ⋯⟩) '' (R + S)) = ⊤ | **Schreier's Lemma**: If `R : Set G` and `H : AddSubgroup G` are complements with
`0 ∈ R`, and if `G` is generated by `S : Set G`, then `H` is generated by the `Set`
`(R + S).image (fun g ↦ g - (hR.toRightFun g))`. | true |
Set.vadd_inter_nonempty_iff' | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {s t : Set α} {x : α}, ((x +ᵥ s) ∩ t).Nonempty ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a - b = x | null | true |
HasDerivWithinAt.deriv_eq_zero | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜},
HasDerivWithinAt f 0 s x → UniqueDiffWithinAt 𝕜 s x → deriv f x = 0 | null | true |
Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β],
t.WF → ∀ {a : α}, Std.DTreeMap.Internal.Impl.Const.get! t a = Std.DTreeMap.Internal.Impl.Const.getD t a default | null | true |
_private.Lean.Widget.InteractiveCode.0.Lean.Widget.ppExprTagged.match_1 | Lean.Widget.InteractiveCode | (motive : Lean.FormatWithInfos → Sort u_1) →
(x : Lean.FormatWithInfos) →
((fmt : Std.Format) → (infos : Lean.PrettyPrinter.InfoPerPos) → motive { fmt := fmt, infos := infos }) → motive x | null | false |
Lean.Compiler.LCNF.PullLetDecls.Context.isCandidateFn | Lean.Compiler.LCNF.PullLetDecls | Lean.Compiler.LCNF.PullLetDecls.Context →
Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure → Lean.FVarIdSet → Lean.Compiler.LCNF.CompilerM Bool | null | true |
Std.DTreeMap.Internal.Impl.Const.entryAtIdxD.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} (x : ℕ) (x_1 : α × β) (size : ℕ) (k : α) (v : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
Std.DTreeMap.Internal.Impl.Const.entryAtIdxD (Std.DTreeMap.Internal.Impl.inner size k v l r) x x_1 =
match compare x l.size with
| Ordering.lt => Std.DTreeMap.Internal.Impl.Const.ent... | null | true |
ENNReal.iSup_add_iSup_le | Mathlib.Basic.ENNReal.Operations | ∀ {ι : Sort u_1} {κ : Sort u_2} {f : ι → ENNReal} {a : ENNReal} [Nonempty ι] [Nonempty κ] {g : κ → ENNReal},
(∀ (i : ι) (j : κ), f i + g j ≤ a) → iSup f + iSup g ≤ a | null | true |
_private.Lean.Compiler.LCNF.InferType.0.Lean.Compiler.LCNF.eqvTypes.match_1 | Lean.Compiler.LCNF.InferType | (motive : Lean.Expr → Lean.Expr → Sort u_1) →
(a b : Lean.Expr) →
((data : Lean.MData) → (a b : Lean.Expr) → motive (Lean.Expr.mdata data a) b) →
((a : Lean.Expr) → (data : Lean.MData) → (b : Lean.Expr) → motive a (Lean.Expr.mdata data b)) →
((f a g b : Lean.Expr) → motive (f.app a) (g.app b)) →
... | null | false |
Nat.chineseRemainderOfMultiset._proof_5 | Mathlib.Data.Nat.ChineseRemainder | ∀ {ι : Type u_1} (s : ι → ℕ) (l : List ι),
Multiset.Nodup ⟦l⟧ →
{x | x ∈ ⟦l⟧}.Pairwise (Function.onFun Nat.Coprime s) → List.Pairwise (Function.onFun Nat.Coprime s) l | null | false |
_private.Mathlib.AlgebraicGeometry.ResidueField.0.AlgebraicGeometry.Scheme.SpecToEquivOfField._proof_5 | Mathlib.AlgebraicGeometry.ResidueField | ∀ (K : Type u_1) [inst : Field K] (X : AlgebraicGeometry.Scheme) (f : (x : ↥X) × (X.residueField x ⟶ ↧K)),
IsLocalHom (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.stalkClosedPointTo (AlgebraicGeometry.Spec.map f.snd))) | null | false |
CategoryTheory.MonoidalCategory.recOn | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
[𝒞 : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.MonoidalCategory C → Sort u_1} →
(t : CategoryTheory.MonoidalCategory C) →
([toMonoidalCategoryStruct : CategoryTheory.MonoidalCategoryStruct C] →
(tensorHom_def :
∀ {X₁ Y₁ X₂ Y₂ : C} (f : X... | null | false |
CategoryTheory.ShortComplex.RightHomologyData.ofIsColimitCokernelCofork._proof_3 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C),
S.g = 0 →
∀ (c : CategoryTheory.Limits.CokernelCofork S.f) (hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Li... | null | false |
associated_zero_iff_eq_zero | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : MonoidWithZero M] (a : M), Associated a 0 ↔ a = 0 | null | true |
Lean.Doc.Parser.BlockCtxt.minIndent | Lean.DocString.Parser | Lean.Doc.Parser.BlockCtxt → ℕ | The block's minimum indentation.
| true |
RatCast.mk | Batteries.Classes.RatCast | {K : Type u} → (ℚ → K) → RatCast K | null | true |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.heapifyDown_children_of_ge_subtree | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} {sz : ℕ} [inst : Ord α] {b : Vector α sz} {j k : Fin sz},
↑j = 2 * ↑k + 1 ∨ ↑j = 2 * ↑k + 2 →
(∀ (m : Fin sz), Batteries.BinaryHeap.InSubtree✝ ↑j ↑m → (compare b[k] b[m]).isGE = true) →
Batteries.BinaryHeap.WF.Children b k → Batteries.BinaryHeap.WF.Children (Batteries.BinaryHeap.heapifyDown... | heapifyDown at j preserves WF.Children at k when j is a child of k,
k dominates everything in j's subtree, and WF.Children already holds at k | true |
_private.Mathlib.CategoryTheory.Equivalence.Symmetry.0.CategoryTheory.Equivalence.congrLeftFunctor._simp_3 | Mathlib.CategoryTheory.Equivalence.Symmetry | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
CategoryTheory.ShortComplex.RightHomologyData.rightHomologyIso | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S : CategoryTheory.ShortComplex C} →
(h : S.RightHomologyData) → [inst_2 : S.HasRightHomology] → S.rightHomology ≅ h.H | The isomorphism `S.rightHomology ≅ h.H` induced by a right homology data `h` for a
short complex `S`. | true |
ZeroAtInftyContinuousMapClass | Mathlib.Topology.ContinuousMap.ZeroAtInfty | (F : Type u_2) →
(α : outParam (Type u_3)) →
(β : outParam (Type u_4)) → [TopologicalSpace α] → [Zero β] → [TopologicalSpace β] → [FunLike F α β] → Prop | `ZeroAtInftyContinuousMapClass F α β` states that `F` is a type of continuous maps which
vanish at infinity.
You should also extend this typeclass when you extend `ZeroAtInftyContinuousMap`. | true |
List.eq_replicate_of_mem._f | Init.Data.List.Lemmas | ∀ {α : Type u_1} (x : List α)
(f : List.below (motive := fun x => ∀ {a : α}, (∀ b ∈ x, b = a) → x = List.replicate x.length a) x) {a : α},
(∀ b ∈ x, b = a) → x = List.replicate x.length a | null | false |
Frm.instConcreteCategoryFrameHomCarrier._proof_1 | Mathlib.Order.Category.Frm | ∀ {X Y : Frm} (f : FrameHom ↑X ↑Y), { hom' := f }.hom' = f | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.isClassQuickConst? | Lean.Meta.Basic | Lean.Name → Lean.MetaM (Lean.LOption Lean.Name) | null | true |
CategoryTheory.GradedObject.BifunctorComp₂₃IndexData.hpq | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9} {J : Type u_10} {r : I₁ × I₂ × I₃ → J}
(self : CategoryTheory.GradedObject.BifunctorComp₂₃IndexData r) (i : I₁ × I₂ × I₃), self.q (i.1, self.p i.2) = r i | null | true |
Std.ExtDHashMap.getKeyD_inter_of_mem_right | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k fallback : α}, k ∈ m₂ → (m₁ ∩ m₂).getKeyD k fallback = m₁.getKeyD k fallback | null | true |
_private.Mathlib.Analysis.Analytic.Constructions.0.AnalyticAt.neg.match_1_1 | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {F : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {x : E}
(motive : AnalyticAt 𝕜 f x → Prop) (hf : AnalyticAt 𝕜 f x),
(∀ (w : FormalMultilinearSer... | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Substitution.0.MvPowerSeries.rescale._simp_4 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
Lean.Environment.getLocalConstantInfos | Lean.Environment | Lean.Environment → optParam Bool false → BaseIO (Array Lean.AsyncConstantInfo) | Returns the constants added in the current module, in elaboration tree pre-order: the top-level
declarations in elaboration order, each followed by its asynchronous sub-declarations, recursively.
The recursive part can optionally be skipped for theorems for when their sub-decls are unimportant
and visiting them would o... | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.eqImp._sparseCasesOn_11 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} →
(t : Lean.Compiler.LCNF.Code pu) →
((fvarId : Lean.FVarId) →
(cidx : ℕ) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive_4 (Lean.Compiler.LCNF.Co... | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.build | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Std.Time.Awareness → Option Std.Time.DateTime | null | true |
_private.Mathlib.AlgebraicGeometry.Geometrically.Integral.0.AlgebraicGeometry.GeometricallyIntegral.eq_geometricallyReduced_inf_geometricallyIrreducible._simp_1_2 | Mathlib.AlgebraicGeometry.Geometrically.Integral | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
Lean.Meta.mkEqRefl | Lean.Meta.AppBuilder | Lean.Expr → Lean.MetaM Lean.Expr | Returns a proof of `a = a`. | true |
WithBot.subtypeOrderIso._proof_5 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : DecidablePred fun x => x = ⊥] (a : α)
(h : a ≠ ⊥),
(fun a => if h : a = ⊥ then ⊥ else ↑⟨a, h⟩) ((fun a => WithBot.unbotD ⊥ (WithBot.map Subtype.val a)) ↑⟨a, h⟩) =
↑⟨a, h⟩ | null | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.oppositeRightAction._proof_19 | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_4) (D : Type u_2) [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (x : Cᵒᵖ) (x_1 : Dᵒᵖ),
(CategoryTheory.MonoidalCategory.MonoidalRightActionS... | null | false |
Std.TreeMap.contains_inter | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
(t₁ ∩ t₂).contains k = (t₁.contains k && t₂.contains k) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.