name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
UniformEquiv.piCongrRight_symm | Mathlib.Topology.UniformSpace.Equiv | ∀ {ι : Type u_4} {β₁ : ι → Type u_5} {β₂ : ι → Type u_6} [inst : (i : ι) → UniformSpace (β₁ i)]
[inst_1 : (i : ι) → UniformSpace (β₂ i)] (F : (i : ι) → β₁ i ≃ᵤ β₂ i),
(UniformEquiv.piCongrRight F).symm = UniformEquiv.piCongrRight fun i => (F i).symm | true |
Disjoint.isCompl_sup_right_of_isCompl_sup_left | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} {a b c : α} [inst : Lattice α] [inst_1 : BoundedOrder α] [IsModularLattice α],
Disjoint a b → IsCompl (a ⊔ b) c → IsCompl a (b ⊔ c) | true |
CauSeq.Completion.ofRat_injective | 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], Function.Injective CauSeq.Completion.ofRat | true |
Lean.Elab.Info.ofOptionInfo.inj | Lean.Elab.InfoTree.Types | ∀ {i i_1 : Lean.Elab.OptionInfo}, Lean.Elab.Info.ofOptionInfo i = Lean.Elab.Info.ofOptionInfo i_1 → i = i_1 | true |
ConvexCone.instCompleteLattice._proof_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : SMul R M] (a b : ConvexCone R M), a ≤ SemilatticeSup.sup a b | false |
_private.Mathlib.Order.LiminfLimsup.0.limsup_finset_sup'._simp_1_4 | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] {s : Finset ι} (H : s.Nonempty) {f : ι → α} {a : α},
(a ≤ s.sup' H f) = ∃ b ∈ s, a ≤ f b | false |
DecompositionMonoid | Mathlib.Algebra.Divisibility.Basic | (α : Type u_1) → [Semigroup α] → Prop | true |
Lean.Lsp.DeclarationParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.DeclarationParams} → t = t' → Lean.Lsp.DeclarationParams.noConfusionType P t t' | false |
Inter.inter | Init.Core | {α : Type u} → [self : Inter α] → α → α → α | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getElem_concat_succ._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {k n m : ℕ}, (n + k < m + k) = (n < m) | false |
Algebra.tensorH1CotangentOfIsLocalization_toLinearMap | Mathlib.RingTheory.Etale.Kaehler | ∀ (R : Type u_1) {S : Type u_2} (T : Type u_3) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] (M : Submonoid S)
[inst_7 : IsLocalization M T],
↑(Algebra.tensorH1CotangentOfIsLocalization R T M) = L... | true |
_private.Mathlib.Probability.StrongLaw.0.ProbabilityTheory.strong_law_aux1._simp_1_10 | Mathlib.Probability.StrongLaw | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
Lean.Meta.Grind.Arith.CommRing.State.mk.injEq | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ (rings : Array Lean.Meta.Grind.Arith.CommRing.CommRing) (typeIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ))
(exprToRingId : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ) (semirings : Array Lean.Meta.Grind.Arith.CommRing.CommSemiring)
(stypeIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ))
(exprToSemiringI... | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Arg.0.Complex.cos_arg._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
_private.Mathlib.SetTheory.ZFC.VonNeumann.0.ZFSet.mem_vonNeumann_succ._simp_1_1 | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {o : Ordinal.{u}} {x : ZFSet.{u}}, (x ∈ ZFSet.vonNeumann o) = (x.rank < o) | false |
CategoryTheory.Triangulated.SpectralObject._sizeOf_inst | Mathlib.CategoryTheory.Triangulated.SpectralObject | (C : Type u_1) →
(ι : Type u_2) →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} ι} →
{inst_2 : CategoryTheory.Limits.HasZeroObject C} →
{inst_3 : CategoryTheory.HasShift C ℤ} →
{inst_4 : CategoryTheory.Preadditive C} →
... | false |
LinearEquiv.mem_transvections_iff_mem_dilatransvections_and_fixedReduce_eq_one | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {V : Type u_2} [inst : AddCommGroup V] {K : Type u_3} [inst_1 : DivisionRing K] [inst_2 : Module K V]
[Module.Finite K V] (e : V ≃ₗ[K] V),
e ∈ LinearEquiv.transvections K V ↔ e ∈ LinearEquiv.dilatransvections K V ∧ e.fixedReduce = 1 | true |
CategoryTheory.Functor.CoconeTypes.isColimit_iff | Mathlib.CategoryTheory.Limits.Types.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J (Type u)} (c : F.CoconeTypes),
c.IsColimit ↔ Nonempty (CategoryTheory.Limits.IsColimit (F.coconeTypesEquiv c)) | true |
List.traverse.eq_2 | Mathlib.Control.Traversable.Instances | ∀ {F : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Applicative F] (f : α → F β) (a : α) (l : List α),
List.traverse f (a :: l) = List.cons <$> f a <*> List.traverse f l | true |
ENNReal.tendsto_nhds_zero | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_1} {f : Filter α} {u : α → ENNReal}, Filter.Tendsto u f (nhds 0) ↔ ∀ ε > 0, ∀ᶠ (x : α) in f, u x ≤ ε | true |
CategoryTheory.Limits.colimMap | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F G : CategoryTheory.Functor J C} →
[inst_2 : CategoryTheory.Limits.HasColimit F] →
[inst_3 : CategoryTheory.Limits.HasColimit G] →
(F ⟶ G) ... | true |
MeasureTheory.OuterMeasure.comap._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_2} {β : Type u_1} (f : α → β) (m : MeasureTheory.OuterMeasure β), m (f '' ∅) = 0 | false |
List.mapAccumr₂.eq_3 | Mathlib.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β → γ → γ × δ) (x : γ) (x_3 : α) (xr : List α)
(y : β) (yr : List β),
List.mapAccumr₂ f (x_3 :: xr) (y :: yr) x =
((f x_3 y (List.mapAccumr₂ f xr yr x).1).1,
(f x_3 y (List.mapAccumr₂ f xr yr x).1).2 :: (List.mapAccumr₂ f xr yr x).2) | true |
CategoryTheory.CommGrpObj.noConfusion | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.CartesianMonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} →
{X : C} →
{t : CategoryTheory.CommGrpObj X} →
{C' : Type u} →
{inst' :... | false |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_insert_of_ne._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α}, a ≠ b → (insert a s).erase b = insert a (s.erase b) | false |
CategoryTheory.Adjunction.Quadruple.op_adj₂ | Mathlib.CategoryTheory.Adjunction.Quadruple | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D C} {G : CategoryTheory.Functor C D}
{R : CategoryTheory.Functor D C} (q : CategoryTheory.Adjunction.Quadruple L F G R), q.op.adj₂ = q... | true |
Finset.prod_le_one | Mathlib.Algebra.Order.BigOperators.GroupWithZero.Finset | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommMonoidWithZero R] [inst_1 : Preorder R] [ZeroLEOneClass R] [PosMulMono R]
{f : ι → R} {s : Finset ι}, (∀ i ∈ s, 0 ≤ f i) → (∀ i ∈ s, f i ≤ 1) → ∏ i ∈ s, f i ≤ 1 | true |
GradedTensorProduct.instRing._proof_15 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | false |
AddZero | Mathlib.Algebra.Group.Defs | Type u_2 → Type u_2 | true |
RatFunc.valuedRatFunc | Mathlib.FieldTheory.RatFunc.AsPolynomial | (K : Type u_1) → [inst : Field K] → Valued (RatFunc K) (WithZero (Multiplicative ℤ)) | true |
Equiv.prodSubtypeFstEquivSubtypeProd._proof_4 | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} (x : { a // p a } × β), p ↑x.1 | false |
_private.Mathlib.Data.Finset.Card.0.Finset.exists_of_one_lt_card_pi._simp_1_1 | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {s : Finset α}, (1 < s.card) = ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b | false |
List.Perm.all_eq | Init.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α} {f : α → Bool}, l₁.Perm l₂ → l₁.all f = l₂.all f | true |
unitary.match_1 | Mathlib.Algebra.Star.Unitary | ∀ (R : Type u_1) [inst : Monoid R] [inst_1 : StarMul R] (B : R)
(motive : B ∈ {U | star U * U = 1 ∧ U * star U = 1} → Prop) (x : B ∈ {U | star U * U = 1 ∧ U * star U = 1}),
(∀ (hB₁ : star B * B = 1) (hB₂ : B * star B = 1), motive ⋯) → motive x | false |
_private.Lean.Elab.Deriving.FromToJson.0.Lean.Elab.Deriving.FromToJson.mkToJsonBodyForStruct.match_1 | Lean.Elab.Deriving.FromToJson | (motive : Bool × Lean.Term → Sort u_1) →
(__discr : Bool × Lean.Term) → ((isOptField : Bool) → (nm : Lean.Term) → motive (isOptField, nm)) → motive __discr | false |
_private.Mathlib.Tactic.Tauto.0.Mathlib.Tactic.Tauto.elabConfig.match_1 | Mathlib.Tactic.Tauto | (motive : DoResultPR Mathlib.Tactic.Tauto.Config Mathlib.Tactic.Tauto.Config PUnit.{1} → Sort u_1) →
(r : DoResultPR Mathlib.Tactic.Tauto.Config Mathlib.Tactic.Tauto.Config PUnit.{1}) →
((a : Mathlib.Tactic.Tauto.Config) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Mathlib.Tactic.Tauto.Config) ... | false |
LinearOrderedAddCommGroupWithTop.sub_self_eq_zero_iff_ne_top._simp_1 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_2} [inst : LinearOrderedAddCommGroupWithTop α] {a : α}, (a - a = 0) = (a ≠ ⊤) | false |
OrderMonoidIso.symm._proof_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β]
(f : α ≃*o β) {a b : β}, f.toOrderIso.symm a ≤ f.toOrderIso.symm b ↔ a ≤ b | false |
TensorProduct.map_comp | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring R₂]
[inst_2 : CommSemiring R₃] {σ₁₂ : R →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R →+* R₃} {M : Type u_7} {N : Type u_8}
{M₂ : Type u_12} {M₃ : Type u_13} {N₂ : Type u_14} {N₃ : Type u_15} [inst_3 : AddCommMonoid M]
[inst_4 : ... | true |
IsUnit.mul_eq_right | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : Monoid M] {a b : M}, IsUnit b → (a * b = b ↔ a = 1) | true |
_private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix._aux_Mathlib_NumberTheory_SiegelsLemma___delab_app__private_Mathlib_NumberTheory_SiegelsLemma_0_Int_Matrix_termT_1 | Mathlib.NumberTheory.SiegelsLemma | Lean.PrettyPrinter.Delaborator.Delab | false |
MeasureTheory.MeasuredSets.continuous_measure | Mathlib.MeasureTheory.Measure.MeasuredSets | ∀ {α : Type u_1} [mα : MeasurableSpace α] {μ : MeasureTheory.Measure α}, Continuous fun s => μ ↑s | true |
_private.Batteries.Util.ExtendedBinder.0.Batteries.ExtendedBinder.«_aux_Batteries_Util_ExtendedBinder___macroRules_Batteries_ExtendedBinder_term∃ᵉ_,__1».match_1 | Batteries.Util.ExtendedBinder | (motive : Option (Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinder)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinder))) →
((ps : Array (Lean.TSyntax `Batteries.ExtendedBinder.extBinder)) → motive (some ps)) →
(Unit → motive none) → motive x | false |
Lean.Elab.checkSyntaxNodeKindAtNamespaces._sunfold | Lean.Elab.Util | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → [Lean.MonadError m] → Lean.Name → Lean.Name → m Lean.Name | false |
Subtype.coe_le_coe._gcongr_2 | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LE α] {p : α → Prop} {x y : Subtype p}, x ≤ y → ↑x ≤ ↑y | false |
Rat.instUniqueInfinitePlace._proof_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ (x : NumberField.InfinitePlace ℚ), x = Rat.infinitePlace | false |
LSeries.positive_of_differentiable_of_eqOn | Mathlib.NumberTheory.LSeries.Positivity | ∀ {a : ℕ → ℂ},
0 ≤ a →
0 < a 1 →
∀ {f : ℂ → ℂ},
Differentiable ℂ f →
∀ {x : ℝ}, LSeries.abscissaOfAbsConv a ≤ ↑x → Set.EqOn f (LSeries a) {s | x < s.re} → ∀ (y : ℝ), 0 < f ↑y | true |
Fin.exists_succAbove_eq_iff._simp_1 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {x y : Fin (n + 1)}, (∃ z, x.succAbove z = y) = (y ≠ x) | false |
Lean.Elab.Tactic.GuardMsgs.FilterSpec.toCtorIdx | Lean.Elab.GuardMsgs | Lean.Elab.Tactic.GuardMsgs.FilterSpec → ℕ | false |
LinearIsometryEquiv.toHomeomorph_trans | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} {E : Type u_5} {E₂ : Type u_6} {E₃ : Type u_7} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {σ₁₃ : R →+* R₃} {σ₃₁ : R₃ →+* R}
{σ₂₃ : R₂ →+* R₃} {σ₃₂ : R₃ →+* R₂} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHo... | true |
WithLp.idemSnd | Mathlib.Analysis.Normed.Lp.ProdLp | {α : Type u_2} →
{β : Type u_3} →
[inst : SeminormedAddCommGroup α] →
[inst_1 : SeminormedAddCommGroup β] → {p : ENNReal} → AddMonoid.End (WithLp p (α × β)) | true |
Set.compl_cIoo | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularOrder α] {a b : α}, (Set.cIoo a b)ᶜ = Set.cIcc b a | true |
unitInterval.symm_bijective | Mathlib.Topology.UnitInterval | Function.Bijective unitInterval.symm | true |
LieAlgebra.SemiDirectSum.recOn | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] →
[inst_4 : LieAlgebra R L] →
{x : L →ₗ⁅R⁆ LieDerivation R K K} →
{motive : K ⋊⁅x⁆ L ... | false |
Lean.MessageData.ofFormatWithInfos.noConfusion | Lean.Message | {P : Sort u} →
{a a' : Lean.FormatWithInfos} →
Lean.MessageData.ofFormatWithInfos a = Lean.MessageData.ofFormatWithInfos a' → (a = a' → P) → P | false |
ZeroAtInftyContinuousMap.compNonUnitalAlgHom._proof_2 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {β : Type u_2} {γ : Type u_3} {δ : Type u_1} [inst : TopologicalSpace β] [inst_1 : TopologicalSpace γ]
[inst_2 : TopologicalSpace δ] [inst_3 : NonUnitalNonAssocSemiring δ] [inst_4 : IsTopologicalSemiring δ]
(g : CocompactMap β γ), ZeroAtInftyContinuousMap.comp 0 g = ZeroAtInftyContinuousMap.comp 0 g | false |
Primrec.eq_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] (f : α → β),
Primrec f = Nat.Primrec fun n => Encodable.encode (Option.map f (Encodable.decode n)) | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Internalize.0.Lean.Meta.Grind.Arith.Linear.internalize.match_3 | Lean.Meta.Tactic.Grind.Arith.Linear.Internalize | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) →
((natStructId : ℕ) → motive (some natStructId)) → ((x : Option ℕ) → motive x) → motive __do_lift | false |
Lean.PrintImportsResult._sizeOf_1 | Lean.Elab.ParseImportsFast | Lean.PrintImportsResult → ℕ | false |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_21 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α) (ha : a ∈ x :: y :: tail),
a ≠ (x :: y :: tail).head ⋯ → 0 < (y :: tail).length | false |
IsOpen.locallyCompactSpace | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] [LocallyCompactSpace X] {s : Set X}, IsOpen s → LocallyCompactSpace ↑s | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Poly.0.Lean.Grind.CommRing.Poly.checkNoUnitMon._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | {motive : Lean.Grind.CommRing.Mon → Sort u} →
(t : Lean.Grind.CommRing.Mon) →
motive Lean.Grind.CommRing.Mon.unit → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Lean.Meta.Simp.SimprocExtension | Lean.Meta.Tactic.Simp.Simproc | Type | true |
ProbabilityTheory.«_aux_Mathlib_Probability_Kernel_Composition_CompNotation___macroRules_ProbabilityTheory_term_∘ₘ__1» | Mathlib.Probability.Kernel.Composition.CompNotation | Lean.Macro | false |
StieltjesFunction.instAddZeroClass._proof_2 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (x : StieltjesFunction R), x + 0 = x | false |
_private.Mathlib.Topology.Metrizable.Uniformity.0.UniformSpace.metrizable_uniformity._simp_1_4 | Mathlib.Topology.Metrizable.Uniformity | ∀ {a : Prop}, (¬¬a) = a | false |
_private.Lean.Meta.Tactic.Symm.0.Lean.Meta.Symm.initFn._sparseCasesOn_4._@.Lean.Meta.Tactic.Symm.3447505512._hygCtx._hyg.2 | Lean.Meta.Tactic.Symm | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
UniformSpace.toCore_toTopologicalSpace | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} (u : UniformSpace α), u.toCore.toTopologicalSpace = u.toTopologicalSpace | true |
CategoryTheory.CartesianMonoidalCategory.prodComparison_fst_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₁} [inst_2 : CategoryTheory.Category.{v₁, u₁} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) (A B : C) {Z : D} (h : F.obj A ⟶ Z),
CategoryTheory.Cate... | true |
Filter.germSetoid | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → Filter α → (β : Type u_5) → Setoid (α → β) | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.next_le_of_lt._proof_1_11 | Init.Data.String.Basic | ∀ {s : String.Slice} {p q : s.Pos} {h : p ≠ s.endPos},
q.offset.byteIdx = p.offset.byteIdx + (q.offset.byteIdx - p.offset.byteIdx) →
q.offset.byteIdx - p.offset.byteIdx = 0 → p.offset.byteIdx < q.offset.byteIdx → False | false |
LinearPMap.instAddAction._proof_1 | 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] (_f₁ _f₂ : E →ₗ[R] F) (x : E →ₗ.[R] F),
(_f₁ + _f₂) +ᵥ x = _f₁ +ᵥ _f₂ +ᵥ x | false |
_private.Mathlib.Geometry.Euclidean.Circumcenter.0.Affine.Simplex.sum_reflectionCircumcenterWeightsWithCircumcenter._simp_1_4 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | false |
HOr.mk._flat_ctor | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → (α → β → γ) → HOr α β γ | false |
_private.Init.Data.String.Lemmas.Iterate.0.Std.Iter.toArray_eq_match_step.match_1.splitter | Init.Data.String.Lemmas.Iterate | {α β : Type u_1} →
(motive : Std.IterStep (Std.Iter β) β → Sort u_2) →
(x : Std.IterStep (Std.Iter β) β) →
((it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out)) →
((it' : Std.Iter β) → motive (Std.IterStep.skip it')) → (Unit → motive Std.IterStep.done) → motive x | true |
Vector.forall_mem_flatMap | Init.Data.Vector.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {n m : ℕ} {p : β → Prop} {xs : Vector α n} {f : α → Vector β m},
(∀ x ∈ xs.flatMap f, p x) ↔ ∀ a ∈ xs, ∀ b ∈ f a, p b | true |
_private.Lean.Compiler.LCNF.ElimDeadBranches.0.Lean.Compiler.LCNF.UnreachableBranches.Value.truncate.match_4 | Lean.Compiler.LCNF.ElimDeadBranches | (motive : ℕ → Sort u_1) →
(remainingDepth : ℕ) → (Unit → motive 0) → ((remainingDepth : ℕ) → motive remainingDepth.succ) → motive remainingDepth | false |
CategoryTheory.Pretriangulated.Triangle.shiftFunctor._proof_3 | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (n : ℤ) {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Pretriangulated.Triangle.mk (n.negOnePow • (Ca... | false |
CategoryTheory.RegularEpi.ofIso._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (e : X ≅ Y)
(s : CategoryTheory.Limits.Cofork (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X)),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofork.ofπ e.hom ⋯).π
((fun s => CategoryTheory.CategoryS... | false |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr._sizeOf_2 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → ℕ | false |
DFinsupp.addCommGroup._proof_4 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → AddCommGroup (β i)] (g : Π₀ (i : ι), β i), ⇑(-g) = -⇑g | false |
FractionalIdeal.den.eq_1 | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
(I : FractionalIdeal S P), I.den = ⟨Exists.choose ⋯, ⋯⟩ | true |
_private.Mathlib.Analysis.Analytic.Order.0.AnalyticAt.analyticOrderAt_deriv_add_one._simp_1_4 | Mathlib.Analysis.Analytic.Order | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b) | false |
Batteries.Tactic.exacts | Batteries.Tactic.Init | Lean.ParserDescr | true |
Matroid.eRk_union_le_eRk_add_encard | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X Y : Set α), M.eRk (X ∪ Y) ≤ M.eRk X + Y.encard | true |
Lean.Parser.Term.doIf._regBuiltin.Lean.Parser.Term.doIf.parenthesizer_51 | Lean.Parser.Do | IO Unit | false |
Std.ExtDTreeMap.Const.get!_diff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.ExtDTreeMap α (fun x => β) cmp}
[inst : Std.TransCmp cmp] [inst_1 : Inhabited β] {k : α},
Std.ExtDTreeMap.Const.get! (t₁ \ t₂) k = if k ∈ t₂ then default else Std.ExtDTreeMap.Const.get! t₁ k | true |
_private.Mathlib.SetTheory.Lists.0.Lists'.toList.match_1.splitter | Mathlib.SetTheory.Lists | {α : Type u_1} →
(motive : (x : Bool) → Lists' α x → Sort u_2) →
(x : Bool) →
(x_1 : Lists' α x) →
((a : α) → motive false (Lists'.atom a)) →
(Unit → motive true Lists'.nil) →
((b : Bool) → (a : Lists' α b) → (l : Lists' α true) → motive true (a.cons' l)) → motive x x_1 | true |
Topology.scottHausdorff | Mathlib.Topology.Order.ScottTopology | (α : Type u_3) → Set (Set α) → [Preorder α] → TopologicalSpace α | true |
MeasureTheory.fundamentalInterior.eq_1 | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] (s : Set α),
MeasureTheory.fundamentalInterior G s = s \ ⋃ g, ⋃ (_ : g ≠ 1), g • s | true |
Unitization.quasispectrum_eq_spectrum_inr | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_3) {A : Type u_4} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (a : A), quasispectrum R a = spectrum R ↑a | true |
Std.Time.Modifier.s.inj | Std.Time.Format.Basic | ∀ {presentation presentation_1 : Std.Time.Number},
Std.Time.Modifier.s presentation = Std.Time.Modifier.s presentation_1 → presentation = presentation_1 | true |
CategoryTheory.instInhabitedIsSplitCoequalizerId._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C},
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_intMin.match_1_1 | Init.Data.BitVec.Lemmas | ∀ (motive : ℕ → ℕ → Prop) (w i : ℕ),
(∀ (x : ℕ), motive 0 x) → (∀ (w : ℕ), motive w.succ 0) → (∀ (w i : ℕ), motive w.succ i.succ) → motive w i | false |
Lean.Meta.SynthInstance.SubgoalsResult | Lean.Meta.SynthInstance | Type | true |
CircleDeg1Lift.semiconj_of_isUnit_of_translationNumber_eq | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ {f₁ f₂ : CircleDeg1Lift},
IsUnit f₁ → IsUnit f₂ → f₁.translationNumber = f₂.translationNumber → ∃ F, Function.Semiconj ⇑F ⇑f₁ ⇑f₂ | true |
instMonoidalClosedSheafOfHasSheafifyOfFunctorOpposite._proof_5 | Mathlib.CategoryTheory.Sites.CartesianClosed | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_3) [inst_1 : CategoryTheory.Category.{u_2, u_3} A] [CategoryTheory.HasSheafify J A]
[inst_3 : CategoryTheory.CartesianMonoidalCategory A]
[inst_4 : CategoryTheory.MonoidalClosed (CategoryTheory.F... | false |
CategoryTheory.Bicategory.HasAbsLeftKanLift.mk._flat_ctor | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
(hasInitial : CategoryTheory.Limits.HasInitial (CategoryTheory.Bicategory.LeftLift f g)),
(∀ {x : B} (h : x ⟶ c), CategoryTheory.Bicategory.LanLift.CommuteWith f g h) →
CategoryTheory.Bicategory.HasAbsLeftKanLift f g | false |
Nat.Partrec.Code.pair.noConfusion | Mathlib.Computability.PartrecCode | {P : Sort u} → {a a_1 a' a'_1 : Nat.Partrec.Code} → a.pair a_1 = a'.pair a'_1 → (a = a' → a_1 = a'_1 → P) → P | false |
Compactum.join_distrib | Mathlib.Topology.Category.Compactum | ∀ (X : Compactum) (uux : Ultrafilter (Ultrafilter X.A)), X.str (X.join uux) = X.str (Ultrafilter.map X.str uux) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.