name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Filter.Germ.LiftRel._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (r : β → γ → Prop) (_f : α → β) (_g : α → γ) (_f' : α → β)
(_g' : α → γ),
(l.germSetoid β) _f _f' →
(l.germSetoid γ) _g _g' → (∀ᶠ (x : α) in l, r (_f x) (_g x)) = ∀ᶠ (x : α) in l, r (_f' x) (_g' x) | false |
ContinuousMultilinearMap.currySumEquiv._proof_11 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (G' : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G']
[inst_2 : NormedSpace 𝕜 G'], SMulCommClass 𝕜 𝕜 G' | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance.eq_def | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ (pat : String.Slice) (patByte : UInt8) (table : Array ℕ) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) (guess : ℕ) (hg : guess < table.size),
String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance✝ pat patByte table ht h guess hg =
if pat.getUTF8Byte { ... | true |
CategoryTheory.Limits.image.lift_mk_comp._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.Limits.HasImage g] (h : Y ⟶ CategoryTheory.Limits.image g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f h) (CategoryTheory.Limits.image.ι g) =
CategoryTheory... | false |
CategoryTheory.Limits.coprod.braiding_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C]
(P Q : C),
(CategoryTheory.Limits.coprod.braiding P Q).inv =
CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inr CategoryTheory.Limits.coprod.inl | true |
PNat.XgcdType.flip_z | Mathlib.Data.PNat.Xgcd | ∀ (u : PNat.XgcdType), u.flip.z = u.w | true |
LieSubmodule.mem_map_of_mem | Mathlib.Algebra.Lie.Submodule | ∀ {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 ∈ N →... | true |
Sum.smul_inl | Mathlib.Algebra.Group.Action.Sum | ∀ {M : Type u_1} {α : Type u_3} {β : Type u_4} [inst : SMul M α] [inst_1 : SMul M β] (a : M) (b : α),
a • Sum.inl b = Sum.inl (a • b) | true |
RingEquiv.ofHomInv_symm_apply | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S) (g : S →+* R)
(h₁ : f.comp g = RingHom.id S) (h₂ : g.comp f = RingHom.id R) (a : S), (RingEquiv.ofRingHom f g h₁ h₂).symm a = g a | true |
CategoryTheory.Limits.limitIsoLimitCurryCompLim | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
(G : CategoryTheory.Functor (J × K) C) →
[inst_3 : CategoryTheory... | true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategoryToUnit._proof_14 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{X : C} (f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
⦃X_1 Y : CategoryTheory.Over (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)⦄ (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruc... | false |
_private.Lean.Compiler.ExternAttr.0.Lean.isExternC._sparseCasesOn_2 | Lean.Compiler.ExternAttr | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Data.List.Cycle.0.Cycle.Subsingleton.congr._simp_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {s : Cycle α}, s.Subsingleton = (s.length ≤ 1) | false |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.ApproximatesLinearOn.norm_fderiv_sub_le._simp_1_1 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {t : Set β} {a : α} {x : β}, (x ∈ a • t) = ∃ y ∈ t, a • y = x | false |
cantorSequence_eq_self_sub_sum_cantorToTernary | Mathlib.Topology.Instances.CantorSet | ∀ (x : ℝ) (n : ℕ),
(cantorSequence x).get n = (x - ∑ i ∈ Finset.range n, Real.ofDigitsTerm (cantorToTernary x).get i) * 3 ^ n | true |
Batteries.UnionFind.equiv_empty._simp_1 | Batteries.Data.UnionFind.Lemmas | ∀ {a b : ℕ}, Batteries.UnionFind.empty.Equiv a b = (a = b) | false |
instMetricSpaceEmpty._proof_5 | Mathlib.Topology.MetricSpace.Defs | ∀ (x x : Empty), 0 = 0 | false |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.isPrimitiveRoot_exp_of_isCoprime._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ (x : ℂ) (n : ℕ), Complex.exp x ^ n = Complex.exp (↑n * x) | false |
groupHomology.δ_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.LongExactSequence | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {X : CategoryTheory.ShortComplex (Rep.{u, u, u} k G)}
(hX : X.ShortExact) {i j : ℕ} (hij : j + 1 = i) (z : (Fin i → G) →₀ ↑X.X₃)
(hz : (CategoryTheory.ConcreteCategory.hom ((groupHomology.inhomogeneousChains X.X₃).d i j)) z = 0)
(y : (Fin i → G) →₀ ↑X.X₂),
... | true |
Std.DTreeMap.Internal.Impl.WF.casesOn | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} [inst : Ord α] {motive : {β : α → Type v} → (a : Std.DTreeMap.Internal.Impl α β) → a.WF → Prop}
{β : α → Type v} {a : Std.DTreeMap.Internal.Impl α β} (t : a.WF),
(∀ {x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} (a : t.Balanced) (a_1 : ∀ [Std.TransOrd α], t.Ordered),
motive t ⋯) →
(∀... | false |
CategoryTheory.Limits.WalkingMulticospan.functorExt.match_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
(motive : CategoryTheory.Limits.WalkingMulticospan J → Sort u_3) →
(j : CategoryTheory.Limits.WalkingMulticospan J) →
((i : J.L) → motive (CategoryTheory.Limits.WalkingMulticospan.left i)) →
((i : J.R) → motive (CategoryTheory.Limits.WalkingMulticospan.... | false |
_private.Lean.Data.Options.0.Lean.Options.mk.inj | Lean.Data.Options | ∀ {map : Lean.NameMap Lean.DataValue} {hasTrace : Bool} {map_1 : Lean.NameMap Lean.DataValue} {hasTrace_1 : Bool},
{ map := map, hasTrace := hasTrace } = { map := map_1, hasTrace := hasTrace_1 } → map = map_1 ∧ hasTrace = hasTrace_1 | true |
Turing.TM2to1.StAct.casesOn | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} →
{motive : Turing.TM2to1.StAct K Γ σ k → Sort u} →
(t : Turing.TM2to1.StAct K Γ σ k) →
((a : σ → Γ k) → motive (Turing.TM2to1.StAct.push a)) →
((a : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StAct... | false |
UInt16.toNat_ofFin | Init.Data.UInt.Lemmas | ∀ (x : Fin UInt16.size), (UInt16.ofFin x).toNat = ↑x | true |
MeasureTheory.Measure.WeaklyRegular.recOn | Mathlib.MeasureTheory.Measure.Regular | {α : Type u_1} →
[inst : MeasurableSpace α] →
[inst_1 : TopologicalSpace α] →
{μ : MeasureTheory.Measure α} →
{motive : μ.WeaklyRegular → Sort u} →
(t : μ.WeaklyRegular) →
([toOuterRegular : μ.OuterRegular] → (innerRegular : μ.InnerRegularWRT IsClosed IsOpen) → motive ⋯) →
... | false |
LinearIsometry.comp_continuous_iff._simp_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
[inst_5 : Module R₂ E₂] (f : E →ₛₗᵢ[σ₁₂] E₂) {α : Type u_11} [inst_6 : TopologicalSpace α] {g : α... | false |
CategoryTheory.ShortComplex.toCyclesNatTrans | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_2 : CategoryTheory.Limits.HasKernels C] →
[inst_3 : CategoryTheory.Limits.HasCokernels C] →
CategoryTheory.ShortComplex.π₁ ⟶ CategoryTheory.ShortComplex.cyclesFuncto... | true |
LieAlgebra.SpecialLinear.val_single | Mathlib.Algebra.Lie.Classical | ∀ {n : Type u_1} {R : Type u₂} [inst : DecidableEq n] [inst_1 : CommRing R] [inst_2 : Fintype n] (i j : n) (h : i ≠ j)
(r : R), ↑((LieAlgebra.SpecialLinear.single i j h) r) = Matrix.single i j r | true |
Task.get | Init.Core | {α : Type u} → Task α → α | true |
FinPartOrd._sizeOf_1 | Mathlib.Order.Category.FinPartOrd | FinPartOrd → ℕ | false |
geom_sum_mul_of_le_one | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [AddLeftReflectLE R] [AddLeftMono R]
[ExistsAddOfLE R] [inst_5 : Sub R] [OrderedSub R] {x : R},
x ≤ 1 → ∀ (n : ℕ), (∑ i ∈ Finset.range n, x ^ i) * (1 - x) = 1 - x ^ n | true |
AlgebraicGeometry.instIsOpenImmersionMapScheme | Mathlib.AlgebraicGeometry.Morphisms.OpenImmersion | ∀ {X Y X' Y' : AlgebraicGeometry.Scheme} (f : X ⟶ X') (g : Y ⟶ Y') [AlgebraicGeometry.IsOpenImmersion f]
[AlgebraicGeometry.IsOpenImmersion g], AlgebraicGeometry.IsOpenImmersion (CategoryTheory.Limits.coprod.map f g) | true |
cfc_nonneg_of_predicate._simp_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [inst_9 : LE A]
[inst_10 : ContinuousFunctionalCalculus... | false |
TrivSqZeroExt.kerIdeal._proof_1 | Mathlib.Algebra.TrivSqZeroExt.Ideal | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [IsCentralScalar R M], SMulCommClass R Rᵐᵒᵖ M | false |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.of_eq.match_1_1 | Batteries.Data.String.Lemmas | ∀ {l m r : List Char}
(motive :
(x : Substring.Raw) →
x.str.toList = l ++ m ++ r →
x.startPos.byteIdx = String.utf8Len l → x.stopPos.byteIdx = String.utf8Len l + String.utf8Len m → Prop)
(x : Substring.Raw) (x_1 : x.str.toList = l ++ m ++ r) (x_2 : x.startPos.byteIdx = String.utf8Len l)
(x_3 : x... | false |
CochainComplex.mappingCone.trianglehMapOfHomotopy_hom₂ | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} {φ₁ : K₁ ⟶ L₁}
{φ₂ : K₂ ⟶ L₂} {a : K₁ ⟶ K₂} {b : L₁ ⟶ L₂}
(H : Homotopy (CategoryTheory.CategoryStruct.comp φ₁ b) (Catego... | true |
Std.TreeSet.get!_ofList_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : Inhabited α] {l : List α} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeSet.ofList l cmp).get! k' = k | true |
WithZero.decidableEq | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_1} → [DecidableEq α] → DecidableEq (WithZero α) | true |
Lean.Compiler.LCNF.CodeDecl.collectUsed | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.CodeDecl pu → optParam Lean.FVarIdHashSet ∅ → Lean.FVarIdHashSet | true |
Function.Injective.isLeftCancelAdd | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₁] [inst_1 : Add M₂] [IsLeftCancelAdd M₂] (f : M₁ → M₂),
Function.Injective f → (∀ (x y : M₁), f (x + y) = f x + f y) → IsLeftCancelAdd M₁ | true |
List.toFinset_filter | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s : List α) (p : α → Bool),
(List.filter p s).toFinset = {x ∈ s.toFinset | p x = true} | true |
Subgroup.isFiniteRelIndex_map_powMonoidHom_of_fg | Mathlib.GroupTheory.FiniteAbelian.Basic | ∀ {A : Type u_1} [inst : CommGroup A] {B : Subgroup A},
B.FG → ∀ {n : ℕ}, n ≠ 0 → (Subgroup.map (powMonoidHom n) B).IsFiniteRelIndex B | true |
Aesop.Frontend.instInhabitedPriority.default | Aesop.Frontend.RuleExpr | Aesop.Frontend.Priority | true |
Real.sin_add_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (n : ℕ), Real.sin (x + ↑n * (2 * Real.pi)) = Real.sin x | true |
UInt8.pow.match_1 | Init.Data.UInt.Basic | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n | false |
_private.Mathlib.Analysis.Complex.ValueDistribution.FirstMainTheorem.0.ValueDistribution.abs_characteristic_sub_characteristic_shift_le._simp_1_2 | Mathlib.Analysis.Complex.ValueDistribution.FirstMainTheorem | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | false |
ZFSet.diff | Mathlib.SetTheory.ZFC.Basic | ZFSet.{u} → ZFSet.{u} → ZFSet.{u} | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.recOn | Lean.Meta.SynthInstance | {motive : Lean.Meta.PreprocessKind✝ → Sort u} →
(t : Lean.Meta.PreprocessKind✝¹) →
motive Lean.Meta.PreprocessKind.noMVars✝ →
motive Lean.Meta.PreprocessKind.mvarsNoOutputParams✝ →
motive Lean.Meta.PreprocessKind.mvarsOutputParams✝ → motive t | false |
AdicCompletion.liftAlgHom._proof_2 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {S : Type u_1} [inst : CommRing S] (I : Ideal S) {m : ℕ}, (I ^ m).IsTwoSided | false |
CategoryTheory.createsColimitOfFullyFaithfulOfLift' | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | true |
Con.commMagma | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_4} → [inst : CommMagma M] → (c : Con M) → CommMagma c.Quotient | true |
_private.Init.Data.List.MapIdx.0.List.mapFinIdx._proof_1 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {β : Type u_2} (as as_1 : List α) (acc : Array β),
as_1.length + 1 + acc.size = as.length → ¬acc.size < as.length → False | false |
_private.Mathlib.Topology.EMetricSpace.Diam.0.Metric.ediam_pos_iff'._simp_1_1 | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} {s : Set X} [inst : EMetricSpace X], (0 < Metric.ediam s) = s.Nontrivial | false |
measurableSet_preimage_up._simp_1 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set (ULift.{u_6, u_1} α)},
MeasurableSet (ULift.up ⁻¹' s) = MeasurableSet s | false |
LinearPMap.comp | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
[inst : Ring R] →
{E : Type u_2} →
[inst_1 : AddCommGroup E] →
[inst_2 : Module R E] →
{F : Type u_3} →
[inst_3 : AddCommGroup F] →
[inst_4 : Module R F] →
{G : Type u_4} →
[inst_5 : AddCommGroup G] →
... | true |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Ideal.isPrime_map_C_iff_isPrime._simp_1_4 | Mathlib.RingTheory.Polynomial.Basic | ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b₁ b₂ : β}, ((a₁, b₁) = (a₂, b₂)) = (a₁ = a₂ ∧ b₁ = b₂) | false |
AddMonoidHom.coe_snd | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : AddZeroClass N], ⇑(AddMonoidHom.snd M N) = Prod.snd | true |
KaehlerDifferential.mulActionBaseChange._proof_1 | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A], SMulCommClass R R A | false |
MvQPF.wSetoid | Mathlib.Data.QPF.Multivariate.Constructions.Fix | {n : ℕ} → {F : TypeVec.{u} (n + 1) → Type u} → [q : MvQPF F] → (α : TypeVec.{u} n) → Setoid ((MvQPF.P F).W α) | true |
Lean.Elab.Term.LetIdDeclView._sizeOf_inst | Lean.Elab.Binders | SizeOf Lean.Elab.Term.LetIdDeclView | false |
ProbabilityTheory.condCDF_le_one | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (a : α) (x : ℝ),
↑(ProbabilityTheory.condCDF ρ a) x ≤ 1 | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.reverse_balLeft._proof_1_18 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (l : Batteries.RBNode α) (v : α) (r r' l' : Batteries.RBNode α),
r' = r.reverse →
l' = l.reverse →
(Batteries.RBNode.node Batteries.RBColor.red l v r).reverse = Batteries.RBNode.node Batteries.RBColor.red r' v l' | false |
CategoryTheory.Monad.beckAlgebraCofork_pt | Mathlib.CategoryTheory.Monad.Coequalizer | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra),
(CategoryTheory.Monad.beckAlgebraCofork X).pt = X | true |
LinearMap.piApply._proof_4 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R], SMulCommClass R R (M → R) | false |
Lean.NameMapExtension | Batteries.Lean.NameMapAttribute | Type → Type | true |
eqOn_of_cfcₙ_eq_cfcₙ._auto_7 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
Batteries.RBNode.Balanced.setBlack | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {t : Batteries.RBNode α} {c : Batteries.RBColor} {n : ℕ},
t.Balanced c n → ∃ n', t.setBlack.Balanced Batteries.RBColor.black n' | true |
AlgebraicGeometry.spread_out_unique_of_isGermInjective | Mathlib.AlgebraicGeometry.SpreadingOut | ∀ {X Y : AlgebraicGeometry.Scheme} {x : ↥X} [X.IsGermInjectiveAt x] (f g : X ⟶ Y) (e : f x = g x),
AlgebraicGeometry.Scheme.Hom.stalkMap f x =
CategoryTheory.CategoryStruct.comp (Y.presheaf.stalkSpecializes ⋯) (AlgebraicGeometry.Scheme.Hom.stalkMap g x) →
∃ U, x ∈ U ∧ CategoryTheory.CategoryStruct.comp U.ι ... | true |
_private.Mathlib.Probability.Kernel.Disintegration.Density.0.ProbabilityTheory.Kernel.tendsto_density_fst_atTop_ae_of_monotone._simp_1_1 | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | false |
_private.Aesop.Rule.0.Aesop.instBEqRegularRule.beq._sparseCasesOn_2 | Aesop.Rule | {motive : Aesop.RegularRule → Sort u} →
(t : Aesop.RegularRule) →
((r : Aesop.UnsafeRule) → motive (Aesop.RegularRule.unsafe r)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Analysis.Asymptotics.Completion.0.«term_̂» | Mathlib.Analysis.Asymptotics.Completion | Lean.TrailingParserDescr | true |
_private.Mathlib.Topology.Sequences.0.FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto._simp_1_6 | Mathlib.Topology.Sequences | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
Std.IterM.findM?_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α m β] [inst_2 : Std.IteratorLoop α m m]
[LawfulMonad m] [Std.Iterators.Finite α m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β}
{f : β → m (ULift.{w, 0} Bool)},
it.findM? f = do
let __do_lift ← it.step
match ↑__do_lift... | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.zero_lt_getElem!_toList_ric_iff._simp_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | false |
Std.Tactic.BVDecide.LRAT.Internal.Entails.noConfusionType | Std.Tactic.BVDecide.LRAT.Internal.Entails | Sort u_1 →
{α : Type u} →
{β : Type v} →
Std.Tactic.BVDecide.LRAT.Internal.Entails α β →
{α' : Type u} → {β' : Type v} → Std.Tactic.BVDecide.LRAT.Internal.Entails α' β' → Sort u_1 | false |
String.Slice.Pattern.Model.ForwardSliceSearcher.matchesAt_iff_getElem._proof_2 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos : s.Pos},
pos.offset.byteIdx + pat.copy.toByteArray.size ≤ s.copy.toByteArray.size →
∀ j < pat.copy.toByteArray.size, pos.offset.byteIdx + j < s.copy.toByteArray.size | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_slope_of_ne._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
MulOpposite.instCoalgebra._proof_8 | Mathlib.RingTheory.Coalgebra.MulOpposite | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A],
SMulCommClass R R (TensorProduct R Aᵐᵒᵖ R) | false |
CategoryTheory.FreeBicategory.Hom.brecOn.eq | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {motive : (a a_1 : B) → CategoryTheory.FreeBicategory.Hom a a_1 → Sort u_1} {a a_1 : B}
(t : CategoryTheory.FreeBicategory.Hom a a_1)
(F_1 :
(a a_2 : B) →
(t : CategoryTheory.FreeBicategory.Hom a a_2) → CategoryTheory.FreeBicategory.Hom.below t → motive a a_2 t),
Categor... | true |
ContinuousMap.instCommCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_2} {A : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : CommCStarAlgebra A],
CompleteSpace C(α, A) | false |
CategoryTheory.Pretriangulated.productTriangle_obj₁ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
(T : J → CategoryTheory.Pretriangulated.Triangle C) [inst_2 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₁]
[inst_3 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₂]
[inst_4 : CategoryTheor... | true |
_private.Init.Prelude.0.ne_false_of_eq_true.match_1_1 | Init.Prelude | ∀ (motive : (x : Bool) → x = true → Prop) (x : Bool) (x_1 : x = true),
(∀ (x : true = true), motive true x) → (∀ (h : false = true), motive false h) → motive x x_1 | false |
Quiver.IsStronglyConnected.nonempty_path | Mathlib.Combinatorics.Quiver.ConnectedComponent | ∀ (V : Type u_2) [inst : Quiver V], Quiver.IsStronglyConnected V → ∀ (i j : V), Nonempty (Quiver.Path i j) | true |
_private.Mathlib.Combinatorics.Schnirelmann.0.schnirelmannDensity_setOf_mod_eq_one._simp_1_4 | Mathlib.Combinatorics.Schnirelmann | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | false |
AddSubmonoid.gciMapComap._proof_3 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_3}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
Function.Injective ⇑f → ∀ (S : AddSubmonoid M), ∀ x ∈ AddSubmonoid.comap f (AddSubmonoid.map f S), x ∈ S | false |
instMetricSpaceOrderDual | Mathlib.Topology.MetricSpace.Defs | {X : Type u_1} → [MetricSpace X] → MetricSpace Xᵒᵈ | true |
groupHomology.chainsMap._proof_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k : Type u_1} [inst : CommRing k], RingHomCompTriple (RingHom.id k) (RingHom.id k) (RingHom.id k) | false |
eq_nnratCast | Mathlib.Data.Rat.Cast.Defs | ∀ {F : Type u_1} {α : Type u_3} [inst : DivisionSemiring α] [inst_1 : FunLike F ℚ≥0 α] [RingHomClass F ℚ≥0 α] (f : F)
(q : ℚ≥0), f q = ↑q | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.mul.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | sizeOf Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.mul✝ = 1 | true |
Lean.Elab.Term.LetConfig.rec | Lean.Elab.Binders | {motive : Lean.Elab.Term.LetConfig → Sort u} →
((nondep usedOnly zeta postponeValue generalize : Bool) →
(eq? : Option Lean.Ident) →
motive
{ nondep := nondep, usedOnly := usedOnly, zeta := zeta, postponeValue := postponeValue,
generalize := generalize, eq? := eq? }) →
(t : Lea... | false |
YoungDiagram.cells_subset_iff | Mathlib.Combinatorics.Young.YoungDiagram | ∀ {μ ν : YoungDiagram}, μ.cells ⊆ ν.cells ↔ μ ≤ ν | true |
CauSeq.Completion.ofRat_neg | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x : β),
CauSeq.Completion.ofRat (-x) = -CauSeq.Completion.ofRat x | true |
Array.eraseP_map | Init.Data.Array.Erase | ∀ {β : Type u_1} {α : Type u_2} {p : α → Bool} {f : β → α} {xs : Array β},
(Array.map f xs).eraseP p = Array.map f (xs.eraseP (p ∘ f)) | true |
PerfectClosure.instCommRing._proof_18 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
(a : PerfectClosure K p), SubNegMonoid.zsmul 0 a = 0 | false |
AlgebraicGeometry.IsSeparated.of_comp | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z)
[AlgebraicGeometry.IsSeparated (CategoryTheory.CategoryStruct.comp f g)], AlgebraicGeometry.IsSeparated f | true |
Topology.IsUpper.isTopologicalSpace_basis | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] [t : TopologicalSpace α] [Topology.IsUpper α] (U : Set α),
IsOpen U ↔ U = Set.univ ∨ ∃ a, (Set.Iic a)ᶜ = U | true |
_private.Mathlib.Topology.Order.LeftRightNhds.0.eventually_mabs_div_lt._simp_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u} (s : Set α), (s ∈ Filter.principal s) = True | false |
Lean.Lsp.DidSaveTextDocumentParams.mk.noConfusion | Lean.Data.Lsp.TextSync | {P : Sort u} →
{textDocument : Lean.Lsp.TextDocumentIdentifier} →
{text? : Option String} →
{textDocument' : Lean.Lsp.TextDocumentIdentifier} →
{text?' : Option String} →
{ textDocument := textDocument, text? := text? } = { textDocument := textDocument', text? := text?' } →
(te... | false |
AddEquivClass.map_add | Mathlib.Algebra.Group.Equiv.Defs | ∀ {F : Type u_9} {A : outParam (Type u_10)} {B : outParam (Type u_11)} {inst : Add A} {inst_1 : Add B}
{inst_2 : EquivLike F A B} [self : AddEquivClass F A B] (f : F) (a b : A), f (a + b) = f a + f b | true |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.extractClosed._proof_1 | Lean.Compiler.LCNF.ExtractClosed | Lean.Compiler.LCNF.Phase.mono ≥ Lean.Compiler.LCNF.Phase.mono | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.