name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Matrix.blockDiag_map | Mathlib.Data.Matrix.Block | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type u_12} {β : Type u_13} (M : Matrix (m × o) (n × o) α)
(f : α → β), (M.map f).blockDiag = fun k => (M.blockDiag k).map f | null | true |
Finset.biUnion_op_vadd_finset | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} [inst : Add α] [inst_1 : DecidableEq α] (s t : Finset α),
(t.biUnion fun a => AddOpposite.op a +ᵥ s) = s + t | null | true |
SymbolicDynamics.FullShift.forbidden | Mathlib.Dynamics.SymbolicDynamics.Basic | {A : Type u_1} →
{G : Type u_2} → [inst : Inhabited A] → [AddMonoid G] → Set (SymbolicDynamics.FullShift.Pattern A G) → Set (G → A) | `forbidden F` is the set of configurations that avoid every pattern in `F`.
Formally: `x ∈ forbidden F` if and only if for every pattern `p ∈ F` and every
monoid element `g : G`, the pattern `p` does not occur in `x` at position `g`.
Intuitively, `forbidden F` is the shift space defined by declaring the finite set
(o... | true |
_private.Init.Data.Slice.List.Lemmas.0.List.toArray_mkSlice_rcc._simp_1_1 | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, Std.Slice.toArray xs = (Std.Slice.toList xs).toArray | null | false |
not_of_iff_false | Init.Core | ∀ {p : Prop}, (p ↔ False) → ¬p | null | true |
Polynomial.scaleRoots_dvd_iff | Mathlib.RingTheory.Polynomial.ScaleRoots | ∀ {R : Type u_1} [inst : CommSemiring R] (p q : Polynomial R) {r : R},
IsUnit r → (p.scaleRoots r ∣ q.scaleRoots r ↔ p ∣ q) | null | true |
SimpleGraph.mk.sizeOf_spec | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} [inst : SizeOf V] (Adj : V → V → Prop) (symm : autoParam (Std.Symm Adj) SimpleGraph.symm._autoParam)
(loopless : autoParam (Std.Irrefl Adj) SimpleGraph.loopless._autoParam),
sizeOf { Adj := Adj, symm := symm, loopless := loopless } = 1 + sizeOf symm + sizeOf loopless | null | true |
_private.Mathlib.Analysis.Convex.Integral.0.Convex.integral_mem._simp_1_3 | Mathlib.Analysis.Convex.Integral | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f : MeasureTheory.SimpleFunc α β} {b : β},
(b ∈ f.range) = (b ∈ Set.range ⇑f) | null | false |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.stepAsHetT_filterMapWithPostcondition.match_3.eq_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type u_1 → Type u_2} {α β : Type u_1} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3) (it' : Std.IterM m β)
(out : β) (h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
... | null | true |
CategoryTheory.Bicategory.LeftLift.whiskering | Mathlib.CategoryTheory.Bicategory.Extension | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
{f : b ⟶ a} →
{g : c ⟶ a} →
{x : B} →
(h : x ⟶ c) →
CategoryTheory.Functor (CategoryTheory.Bicategory.LeftLift f g)
(CategoryTheory.Bicategory.LeftLift f (CategoryTheory.CategorySt... | Whiskering a 1-morphism is a functor. | true |
_private.Init.Data.Ord.Vector.0.Vector.instReflOrd._proof_1 | Init.Data.Ord.Vector | ∀ {α : Type u_1} [inst : Ord α] [Std.ReflOrd α] {n : ℕ}, Std.ReflOrd (Vector α n) | null | false |
Lean.Elab.Tactic.liftMetaTacticAux | Lean.Elab.Tactic.Basic | {α : Type} → (Lean.MVarId → Lean.MetaM (α × List Lean.MVarId)) → Lean.Elab.Tactic.TacticM α | null | true |
Bool.recOn._@.Mathlib.Util.CompileInductive.3618634379._hygCtx._hyg.5 | Mathlib.Util.CompileInductive | {motive : Bool → Sort u} → (t : Bool) → motive false → motive true → motive t | null | false |
Topology.IsInducing.isOpenMap | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
Topology.IsInducing f → IsOpen (Set.range f) → IsOpenMap f | An inducing map with an open range is an open map. | true |
Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_acChange!_1 | Mathlib.Tactic.Convert | Lean.Macro | null | false |
CategoryTheory.CartesianMonoidalCategory.whiskerRight_toUnit_comp_leftUnitor_hom_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] (X Y : C)
{Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.SemiCartesianMonoidalCategory.toUnit X) Y)
(CategoryTheory.... | null | true |
CategoryTheory.Limits.ker._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] {X Y Z : CategoryTheory.Arrow C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Limits.kernel.lift Z.hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory... | null | false |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.mapCycles₁_quotientGroupMk'_epi._simp_2 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u, u, u} k G} (x : G →₀ ↑A),
(x ∈ groupHomology.cycles₁ A) = ((x.sum fun g a => (A.ρ g⁻¹) a) = x.sum fun x a => a) | null | false |
CategoryTheory.HasShift.recOn | Mathlib.CategoryTheory.Shift.Basic | {C : Type u} →
{A : Type u_2} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : AddMonoid A] →
{motive : CategoryTheory.HasShift C A → Sort u_1} →
(t : CategoryTheory.HasShift C A) →
((shift : CategoryTheory.Functor (CategoryTheory.Discrete A) (CategoryTheory.Functor C C)... | null | false |
MeasureTheory.Measure.ext_of_generateFrom_of_iUnion | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (C : Set (Set α)) (B : ℕ → Set α),
m0 = MeasurableSpace.generateFrom C →
IsPiSystem C → ⋃ i, B i = Set.univ → (∀ (i : ℕ), B i ∈ C) → (∀ (i : ℕ), μ (B i) ≠ ⊤) → (∀ s ∈ C, μ s = ν s) → μ = ν | Two measures are equal if they are equal on the π-system generating the σ-algebra,
and they are both finite on an increasing spanning sequence of sets in the π-system.
This lemma is formulated using `iUnion`.
`FiniteSpanningSetsIn.ext` is a reformulation of this lemma. | true |
ProbabilityTheory.avgRisk_countable | Mathlib.Probability.Decision.Risk.Countable | ∀ {Θ : Type u_1} {𝓧 : Type u_3} {𝓨 : Type u_5} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
{m𝓨 : MeasurableSpace 𝓨} {ℓ : Θ → 𝓨 → ENNReal} {P : ProbabilityTheory.Kernel Θ 𝓧} {κ : ProbabilityTheory.Kernel 𝓧 𝓨}
{π : MeasureTheory.Measure Θ} [Countable Θ] [MeasurableSingletonClass Θ],
ProbabilityTheor... | null | true |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.fac_app | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) {f : CategoryTheory.Arrow C},
CategoryTheory.CategoryStruct.comp (data.i.app f) (data.p.app f) = f.hom | null | true |
_aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___unexpand_LinearIsometryEquiv_2 | Mathlib.Analysis.Normed.Operator.LinearIsometry | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Basic.0.SimpleGraph.Walk.mem_darts_iff_infix_support._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {u' v' : V}, ∀ j < [u', v'].length, 0 < [u', v'].length | null | false |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.msb_ofFnBE._proof_1_5 | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ}, -1 * ↑n + 1 ≤ 0 → 0 < n | null | false |
CategoryTheory.Limits.FormalCoproduct.mk.inj | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} {I : Type w} {obj : I → C} {I_1 : Type w} {obj_1 : I_1 → C},
{ I := I, obj := obj } = { I := I_1, obj := obj_1 } → I = I_1 ∧ obj ≍ obj_1 | null | true |
isEmbedding_of_iSup_eq_top_of_preimage_subset_range | Mathlib.Topology.LocalAtTarget | ∀ {X : Type u_6} {Y : Type u_7} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y),
Continuous f →
∀ {ι : Type u_4} (U : ι → TopologicalSpace.Opens Y),
Set.range f ⊆ ↑(iSup U) →
∀ (V : ι → Type u_5) [inst_2 : (i : ι) → TopologicalSpace (V i)] (iV : (i : ι) → V i → X),
(∀... | Given a continuous map `f : X → Y` between topological spaces.
Suppose we have an open cover `U i` of the range of `f`, and a family of continuous maps `V i → X`
whose images are a cover of `X` that is coarser than the pullback of `U` under `f`.
To check that `f` is an embedding it suffices to check that `V i → Y` is a... | true |
Nat.even_mul | Mathlib.Algebra.Group.Nat.Even | ∀ {m n : ℕ}, Even (m * n) ↔ Even m ∨ Even n | null | true |
Submonoid.unitsTypeEquivIsUnitSubmonoid._proof_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : Monoid M] (x : ↥(IsUnit.submonoid M)), (fun x => ⟨↑x, ⋯⟩) ((fun x => IsUnit.unit ⋯) x) = x | null | false |
Subring.instCompleteLattice.match_1 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : NonAssocRing R] (_x : R) (motive : (∃ n, ↑n = _x) → Prop) (x : ∃ n, ↑n = _x),
(∀ (n : ℤ) (hn : ↑n = _x), motive ⋯) → motive x | null | false |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape.ici | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : WellFoundedLT J] →
{X Y : C} →
... | A transfinite composition of shape `J` of morphisms in `W` induces a transfinite
composition of shape `Set.Ici j` (for any `j : J`). | true |
TrivSqZeroExt.kerIdeal._proof_2 | Mathlib.Algebra.TrivSqZeroExt.Ideal | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
IsScalarTower R R M | null | false |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.tacticSyntax.match_1 | Mathlib.Tactic.Widget.LibraryRewrite | (motive : Lean.MVarId × Lean.BinderInfo → Sort u_1) →
(x : Lean.MVarId × Lean.BinderInfo) →
((mvarId : Lean.MVarId) → (snd : Lean.BinderInfo) → motive (mvarId, snd)) → motive x | null | false |
Flag.maxChain | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} [inst : LE α] (s : Flag α), IsMaxChain (fun x1 x2 => x1 ≤ x2) ↑s | null | true |
Lean.PrefixTreeNode.rec | Lean.Data.PrefixTree | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1} →
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{... | null | false |
Mathlib.Tactic.ClickSuggestions.RwLemma.mk.noConfusion | Mathlib.Tactic.ClickSuggestions.Rewrite | {P : Sort u} →
{name : Mathlib.Tactic.ClickSuggestions.Premise} →
{symm : Bool} →
{name' : Mathlib.Tactic.ClickSuggestions.Premise} →
{symm' : Bool} →
{ name := name, symm := symm } = { name := name', symm := symm' } → (name = name' → symm = symm' → P) → P | null | false |
Std.HashSet.erase_emptyWithCapacity | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {a : α} {c : ℕ},
(Std.HashSet.emptyWithCapacity c).erase a = Std.HashSet.emptyWithCapacity c | null | true |
Set.vadd_set_univ_pi | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {M : Type u_5} {ι : Type u_6} {π : ι → Type u_7} [inst : (i : ι) → VAdd M (π i)] (c : M) (s : (i : ι) → Set (π i)),
c +ᵥ Set.univ.pi s = Set.univ.pi (c +ᵥ s) | null | true |
HomologicalComplex.cyclesFunctor_map | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} (c : ComplexShape ι) (i : ι) [inst_2 : CategoryTheory.CategoryWithHomology C]
{X Y : HomologicalComplex C c} (f : X ⟶ Y),
(HomologicalComplex.cyclesFunctor C c i).map f = HomologicalCo... | null | true |
Nat.Partrec.Code.zero.elim | Mathlib.Computability.PartrecCode | {motive : Nat.Partrec.Code → Sort u} → (t : Nat.Partrec.Code) → t.ctorIdx = 0 → motive Nat.Partrec.Code.zero → motive t | null | false |
AlgebraicTopology.NormalizedMooreComplex.objD._proof_1 | Mathlib.AlgebraicTopology.MooreComplex | ∀ (n : ℕ) (i : Fin (n + 1)), i.succ ∈ Finset.univ | null | false |
Function.iterate_zero | Mathlib.Logic.Function.Iterate | ∀ {α : Type u} (f : α → α), f^[0] = id | null | true |
ComplexShape.Embedding.not_boundaryGE_next' | Mathlib.Algebra.Homology.Embedding.Boundary | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') [e.IsRelIff]
{j k : ι}, ¬e.BoundaryGE j → c.next j = k → ¬e.BoundaryGE k | null | true |
IsSeqCompact.exists_tendsto_of_frequently_mem | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : UniformSpace X] {s : Set X},
IsSeqCompact s →
∀ {u : ℕ → X}, (∃ᶠ (n : ℕ) in Filter.atTop, u n ∈ s) → CauchySeq u → ∃ x ∈ s, Filter.Tendsto u Filter.atTop (nhds x) | null | true |
String.Slice.Pos.revSkipWhile_string_eq_revSkipWhile_toSlice | Init.Data.String.Lemmas.Pattern.String.ForwardPattern | ∀ {pat : String} {s : String.Slice} (curr : s.Pos), curr.revSkipWhile pat = curr.revSkipWhile pat.toSlice | null | true |
Int.isSome_getElem?_toArray_rco_eq | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ((m...n).toArray[i]?.isSome = true) = (i < (n - m).toNat) | null | true |
_private.Batteries.Data.MLList.Basic.0.MLList.Spec.noConfusion | Batteries.Data.MLList.Basic | {P : Sort u_1} →
{m : Type u → Type u} →
{t : MLList.Spec✝ m} →
{m' : Type u → Type u} → {t' : MLList.Spec✝ m'} → m = m' → t ≍ t' → MLList.Spec.noConfusionType✝ P t t' | null | false |
Antivary.div_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : CommGroup β] [inst_2 : LinearOrder β]
[IsOrderedMonoid β] {f : ι → α} {g₁ g₂ : ι → β}, Antivary f g₁ → Monovary f g₂ → Antivary f (g₁ / g₂) | null | true |
Rat.cast_min | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] (p q : ℚ), ↑(min p q) = min ↑p ↑q | null | true |
rexp_neg_quadratic_isLittleO_rpow_atTop | Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation | ∀ {a : ℝ}, a < 0 → ∀ (b s : ℝ), (fun x => Real.exp (a * x ^ 2 + b * x)) =o[Filter.atTop] fun x => x ^ s | null | true |
Mathlib.Meta.FunProp.Config.mk | Mathlib.Tactic.FunProp.Types | ℕ → ℕ → Mathlib.Meta.FunProp.Config | null | true |
ZMod.val_le | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} [NeZero n] (a : ZMod n), a.val ≤ n | null | true |
_private.Lean.Data.KVMap.0.Lean.KVMap.insert.match_1 | Lean.Data.KVMap | (motive : Lean.KVMap → Lean.Name → Lean.DataValue → Sort u_1) →
(x : Lean.KVMap) →
(x_1 : Lean.Name) →
(x_2 : Lean.DataValue) →
((m : List (Lean.Name × Lean.DataValue)) →
(k : Lean.Name) → (v : Lean.DataValue) → motive { entries := m } k v) →
motive x x_1 x_2 | null | false |
Matroid.sigma._proof_4 | Mathlib.Combinatorics.Matroid.Sum | ∀ {ι : Type u_1} {α : ι → Type u_2} (M : (i : ι) → Matroid (α i)), ∃ B, ∀ (i : ι), (M i).IsBase (Sigma.mk i ⁻¹' B) | null | false |
HomologicalComplex.truncLE'ToRestriction_naturality | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K L : HomologicalComplex C c'} (φ : K ⟶ L) (e : c.Embedding c') [inst_2 : e.IsTruncLE]
[inst_3 : ∀ (i' : ι'), K.HasHomology... | null | true |
CategoryTheory.Limits.WalkingParallelPair.one.elim | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {motive : CategoryTheory.Limits.WalkingParallelPair → Sort u} →
(t : CategoryTheory.Limits.WalkingParallelPair) →
t.ctorIdx = 1 → motive CategoryTheory.Limits.WalkingParallelPair.one → motive t | null | false |
GenContFract.IntFractPair.seq1.eq_1 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] (v : K),
GenContFract.IntFractPair.seq1 v =
(GenContFract.IntFractPair.of v, Stream'.Seq.tail ⟨GenContFract.IntFractPair.stream v, ⋯⟩) | null | true |
Nat.lt_wfRel | Init.WF | WellFoundedRelation ℕ | null | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_val_Iio._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
_private.Mathlib.RingTheory.Extension.Presentation.Submersive.0.Algebra.PreSubmersivePresentation.jacobian_reindex._simp_1_4 | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type u₁} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Semiring C] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra R C]
(φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B), ⇑φ₁ ∘ ⇑φ₂ = ⇑(φ₁.comp φ₂) | null | false |
Lean.AttributeImpl.applicationTime._inherited_default | Lean.Attributes | Lean.AttributeApplicationTime | null | false |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_succ_left_deg._simp_1_13 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) | null | false |
ProbabilityTheory.setBernoulli._proof_1 | Mathlib.Probability.Distributions.SetBernoulli | IsScalarTower ENNReal ENNReal ENNReal | null | false |
Tactic.ComputeAsymptotics.MultiseriesExpansion.mk_eq_mk_iff_iff | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | ∀ {basis_hd : ℝ → ℝ} {basis_tl : List (ℝ → ℝ)}
(ms : Tactic.ComputeAsymptotics.MultiseriesExpansion (basis_hd :: basis_tl))
(s : Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl) (f : ℝ → ℝ),
Tactic.ComputeAsymptotics.MultiseriesExpansion.mk s f = ms ↔ ms.seq = s ∧ ms.toFun = f | null | true |
instCoeSortProfiniteGrpType | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | CoeSort ProfiniteGrp.{u} (Type u) | null | true |
Topology.IsQuotientMap.trivializationOfSMulDisjoint._proof_9 | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_2} {G : Type u_1} [inst : Group G] [inst_1 : MulAction G E] (U : Set E),
(∀ (g : G), ((fun x => g • x) '' U ∩ U).Nonempty → g = 1) →
∀ {g₁ g₂ : G}, g₁ ≠ g₂ → Disjoint ((fun x => g₁ • x) ⁻¹' U) ((fun x => g₂ • x) ⁻¹' U) | null | false |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.inv_naturality | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) [H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f]
{U V : (TopologicalSpace.Opens ↑X.toTopCat)ᵒᵖ} (i : U ⟶ V),
CategoryTheory.CategoryStruct.comp (X.presheaf.map i)
(AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.invApp f (Opposite.uno... | null | true |
_private.Mathlib.Data.Set.Finite.Lemmas.0.Set.exists_max_image.match_1_1 | Mathlib.Data.Set.Finite.Lemmas | ∀ {α : Type u_1} (s : Set α) (motive : s.Nonempty → Prop) (x : s.Nonempty),
(∀ (x : α) (hx : x ∈ s), motive ⋯) → motive x | null | false |
LightCondensed.freeForgetAdjunction | Mathlib.Condensed.Light.Module | (R : Type u) → [inst : Ring R] → LightCondensed.free R ⊣ LightCondensed.forget R | The condensed version of the free-forgetful adjunction. | true |
Std.ExtDHashMap.contains_of_contains_insertIfNew | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β k},
(m.insertIfNew k v).contains a = true → (k == a) = false → m.contains a = true | null | true |
VonNeumannAlgebra.zero_mem'._inherited_default | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} {inst : NormedAddCommGroup H} {inst_1 : InnerProductSpace ℂ H} {inst_2 : CompleteSpace H}
(carrier : Set (H →L[ℂ] H)), (∀ (r : ℂ), (algebraMap ℂ (H →L[ℂ] H)) r ∈ carrier) → 0 ∈ carrier | null | false |
Order.krullDim_int | Mathlib.Order.KrullDimension | Order.krullDim ℤ = ⊤ | null | true |
_private.Mathlib.Tactic.NormNum.Result.0.Mathlib.Meta.NormNum.isNat.natElim.match_1_1 | Mathlib.Tactic.NormNum.Result | ∀ {p : ℕ → Prop} (motive : (x x_1 : ℕ) → Mathlib.Meta.NormNum.IsNat x x_1 → p x_1 → Prop) (x x_1 : ℕ)
(x_2 : Mathlib.Meta.NormNum.IsNat x x_1) (x_3 : p x_1),
(∀ (n : ℕ) (h : p n), motive (↑n) n ⋯ h) → motive x x_1 x_2 x_3 | null | false |
MvPolynomial.support_rename_killCompl_subset | Mathlib.Algebra.MvPolynomial.Rename | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] {p : MvPolynomial τ R} {f : σ → τ}
(hf : Function.Injective f), ((MvPolynomial.rename f) ((MvPolynomial.killCompl hf) p)).support ⊆ p.support | null | true |
DirectSum.lid | Mathlib.Algebra.DirectSum.Module | (R : Type u) →
[inst : Semiring R] →
(M : Type v) →
(ι : optParam (Type u_1) PUnit.{u_1 + 1}) →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → [Unique ι] → (DirectSum ι fun x => M) ≃ₗ[R] M | The natural linear equivalence between `⨁ _ : ι, M` and `M` when `Unique ι`. | true |
MeasureTheory.Measure.rnDeriv_withDensity_withDensity_rnDeriv_left | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → ENNReal} (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ]
[MeasureTheory.SigmaFinite ν],
(∀ᵐ (x : α) ∂μ, f x ≠ ⊤) → ((ν.withDensity (μ.rnDeriv ν)).withDensity f).rnDeriv ν =ᵐ[ν] (μ.withDensity f).rnDeriv ν | Auxiliary lemma for `rnDeriv_withDensity_left`. | true |
Array.back.congr_simp | Init.Data.List.ToArray | ∀ {α : Type u} (xs xs_1 : Array α) (e_xs : xs = xs_1) (h : 0 < xs.size), xs.back h = xs_1.back ⋯ | null | true |
AdicCompletion.instCommRingAdicCauchySequence | Mathlib.RingTheory.AdicCompletion.Algebra | {R : Type u_1} → [inst : CommRing R] → (I : Ideal R) → CommRing (AdicCompletion.AdicCauchySequence I R) | null | true |
CochainComplex.homOfDegreewiseSplit | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(S : CategoryTheory.ShortComplex (CochainComplex C ℤ)) →
((n : ℤ) → (S.map (HomologicalComplex.eval C (ComplexShape.up ℤ) n)).Splitting) →
(S.X₃ ⟶ (CategoryTheory.shiftFunctor (CochainC... | The canonical morphism `S.X₃ ⟶ S.X₁⟦(1 : ℤ)⟧` attached to a degreewise split
short exact sequence of cochain complexes. | true |
_private.Mathlib.Tactic.NormNum.ModEq.0.Mathlib.Meta.NormNum.evalNatModEq.match_1 | Mathlib.Tactic.NormNum.ModEq | (αP : Q(Type)) →
(e : Q(«$αP»)) →
(motive : (b : Bool) × Mathlib.Meta.NormNum.BoolResult e b → Sort u_1) →
(__discr : (b : Bool) × Mathlib.Meta.NormNum.BoolResult e b) →
((b : Bool) → (pb : Mathlib.Meta.NormNum.BoolResult e b) → motive ⟨b, pb⟩) → motive __discr | null | false |
upperSemicontinuous_biInf | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {ι : Sort u_4} {δ : Type u_5} [inst_1 : CompleteLinearOrder δ]
{p : ι → Prop} {f : (i : ι) → p i → α → δ},
(∀ (i : ι) (hi : p i), UpperSemicontinuous (f i hi)) → UpperSemicontinuous fun x' => ⨅ i, ⨅ (hi : p i), f i hi x' | null | true |
Lean.IR.Alt.brecOn | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.Alt → Sort u} →
{motive_2 : Lean.IR.FnBody → Sort u} →
{motive_3 : Array Lean.IR.Alt → Sort u} →
{motive_4 : List Lean.IR.Alt → Sort u} →
(t : Lean.IR.Alt) →
((t : Lean.IR.Alt) → t.below → motive_1 t) →
((t : Lean.IR.FnBody) → t.below → motive_2 t) →
... | null | false |
AddOpposite.instNeg.eq_1 | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} [inst : Neg α], AddOpposite.instNeg = { neg := fun x => AddOpposite.op (-AddOpposite.unop x) } | null | true |
_private.Std.Time.Time.HourMarker.0.Std.Time.HourMarker.toAbsolute._proof_1 | Std.Time.Time.HourMarker | 12 ≤ 23 | null | false |
Equiv.Perm.one_lt_of_mem_cycleType | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α} {n : ℕ}, n ∈ σ.cycleType → 1 < n | null | true |
Std.Internal.List.Const.getKeyD_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [inst_1 : EquivBEq α] {β : Type v} {f : α → β → Bool} {l : List ((_ : α) × β)}
{k fallback : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKeyD k (List.filter (fun p => f p.fst p.snd) l) fallback =
((Std.Internal.List.getKey? k l).pfilter fun x h => f x (Std.Int... | null | true |
Nat.two_pow_pred_mul_two | Init.Data.Nat.Lemmas | ∀ {w : ℕ}, 0 < w → 2 ^ (w - 1) * 2 = 2 ^ w | null | true |
Lean.Meta.Config.ctxApprox._default | Lean.Meta.Basic | Bool | null | false |
_private.Mathlib.Algebra.Group.Defs.0.npowBinRec.go_spec._proof_1_6 | Mathlib.Algebra.Group.Defs | ∀ (k' : ℕ), k' ≠ 0 → ¬2 * k' = 0 | null | false |
AddGroupNormClass.toAddGroupSeminormClass | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} {inst : AddGroup α} {inst_1 : AddCommMonoid β}
{inst_2 : PartialOrder β} {inst_3 : FunLike F α β} [self : AddGroupNormClass F α β], AddGroupSeminormClass F α β | null | true |
AlgebraicGeometry.Scheme.Cover.RelativeGluingData.instCategoryI₀Cover._proof_7 | Mathlib.AlgebraicGeometry.RelativeGluing | ∀ {S : AlgebraicGeometry.Scheme} {𝒰 : S.OpenCover} [inst : CategoryTheory.Category.{u_3, u_1} 𝒰.I₀]
[inst_1 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰] (d : AlgebraicGeometry.Scheme.Cover.RelativeGluingData 𝒰)
[inst_2 : Small.{u_2, u_1} 𝒰.I₀] [inst_3 : Quiver.IsThin 𝒰.I₀],
autoParam
(∀ {X Y : d.... | null | false |
_private.Mathlib.Analysis.Convex.Deriv.0.bddBelow_slope_lt_of_mem_interior.match_1_1 | Mathlib.Analysis.Convex.Deriv | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] {s : Set 𝕜} {f : 𝕜 → 𝕜} {x : 𝕜} (y' : 𝕜)
(motive : y' ∈ slope f x '' {y | y ∈ s ∧ x < y} → Prop) (x_1 : y' ∈ slope f x '' {y | y ∈ s ∧ x < y}),
(∀ (z : 𝕜) (hz : z ∈ {y | y ∈ s ∧ x < y}) (hz' : slope f x z = y'), motive ⋯) → motive x_1 | null | false |
Sum.swap_rightInverse | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v}, Function.RightInverse Sum.swap Sum.swap | null | true |
NonUnitalSubring.instSetLike | Mathlib.RingTheory.NonUnitalSubring.Defs | {R : Type u} → [inst : NonUnitalNonAssocRing R] → SetLike (NonUnitalSubring R) R | null | true |
Filter.Germ.instDivisionRing._proof_6 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u_2} {β : Type u_1} {φ : Ultrafilter α} [DivisionRing β], Nontrivial ((↑φ).Germ β) | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.forIn_filterMapWithPostcondition.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {β₂ : Type u_1} (motive : Option β₂ → Sort u_2) (h_1 : (c : β₂) → motive (some c)) (h_2 : Unit → motive none),
(match none with
| some c => h_1 c
| none => h_2 ()) =
h_2 () | null | true |
LinearMap.shortComplexKer._proof_1 | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_1}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N),
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom f.ker.subtype) (ModuleCat.ofHom f) = 0 | null | false |
ContinuousLinearEquiv.conjContinuousAlgEquiv_apply_apply | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜 : Type u_1} {G : Type u_4} {H : Type u_5} [inst : AddCommGroup G] [inst_1 : AddCommGroup H]
[inst_2 : NormedField 𝕜] [inst_3 : Module 𝕜 G] [inst_4 : Module 𝕜 H] [inst_5 : TopologicalSpace G]
[inst_6 : TopologicalSpace H] [inst_7 : IsTopologicalAddGroup G] [inst_8 : IsTopologicalAddGroup H]
[inst_9 : Cont... | null | true |
MulOpposite.instSemifield._proof_2 | Mathlib.Algebra.Field.Opposite | ∀ {α : Type u_1} [inst : Semifield α] (a : αᵐᵒᵖ), DivisionSemiring.zpow 0 a = 1 | null | false |
semicontinuous_restrict_iff._simp_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {r : α → β → Prop} {s : Set α},
Semicontinuous (s.restrict r) = SemicontinuousOn r s | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.