name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CochainComplex.HomComplex.CohomologyClass.toSmallShiftedHom_mk | Mathlib.Algebra.Homology.DerivedCategory.SmallShiftedHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {K L : CochainComplex C ℤ}
{n : ℤ}
[inst_2 :
CategoryTheory.Localization.HasSmallLocalizedShiftedHom (HomologicalComplex.quasiIso C (ComplexShape.up ℤ)) ℤ K L]
(x : CochainComplex.HomComplex.Cocycle K L n),
(CochainComplex.HomComplex.CohomologyClass.mk x).toSmallShiftedHom =
CategoryTheory.Localization.SmallShiftedHom.mk (HomologicalComplex.quasiIso C (ComplexShape.up ℤ))
(CochainComplex.HomComplex.Cocycle.equivHomShift.symm x) | true |
RightPreLieRing.instLeftPreLieRingMulOpposite | Mathlib.Algebra.NonAssoc.PreLie.Basic | {L : Type u_2} → [RightPreLieRing L] → LeftPreLieRing Lᵐᵒᵖ | true |
Lean.Meta.Grind.EMatch.Choice.noConfusion | Lean.Meta.Tactic.Grind.EMatch | {P : Sort u} → {t t' : Lean.Meta.Grind.EMatch.Choice} → t = t' → Lean.Meta.Grind.EMatch.Choice.noConfusionType P t t' | false |
IsRightUniformAddGroup.rec | Mathlib.Topology.Algebra.IsUniformGroup.Defs | {G : Type u_7} →
[inst : UniformSpace G] →
[inst_1 : AddGroup G] →
{motive : IsRightUniformAddGroup G → Sort u} →
([toIsTopologicalAddGroup : IsTopologicalAddGroup G] →
(uniformity_eq : uniformity G = Filter.comap (fun x => x.2 + -x.1) (nhds 0)) → motive ⋯) →
(t : IsRightUniformAddGroup G) → motive t | false |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.rankFinite_iff_cRank_lt_aleph0._simp_1_6 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u}, Finite α = (Cardinal.mk α < Cardinal.aleph0) | false |
AlgebraicGeometry.ExistsHomHomCompEqCompAux.mk.inj | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u} {inst : CategoryTheory.Category.{u, u} I} {S X : AlgebraicGeometry.Scheme}
{D : CategoryTheory.Functor I AlgebraicGeometry.Scheme} {t : D ⟶ (CategoryTheory.Functor.const I).obj S} {f : X ⟶ S}
{c : CategoryTheory.Limits.Cone D} {hc : CategoryTheory.Limits.IsLimit c} {i : I} {a : D.obj i ⟶ X}
{ha : t.app i = CategoryTheory.CategoryStruct.comp a f} {b : D.obj i ⟶ X}
{hb : t.app i = CategoryTheory.CategoryStruct.comp b f}
{hab : CategoryTheory.CategoryStruct.comp (c.π.app i) a = CategoryTheory.CategoryStruct.comp (c.π.app i) b}
{𝒰S : S.OpenCover} {h𝒰S : ∀ (i : 𝒰S.I₀), AlgebraicGeometry.IsAffine (𝒰S.X i)}
{𝒰X :
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S).I₀) →
((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S).X i).OpenCover}
{h𝒰X :
∀ (i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S).I₀) (j : (𝒰X i).I₀),
AlgebraicGeometry.IsAffine ((𝒰X i).X j)}
{c_1 : CategoryTheory.Limits.Cone D} {hc_1 : CategoryTheory.Limits.IsLimit c_1} {i_1 : I} {a_1 : D.obj i_1 ⟶ X}
{ha_1 : t.app i_1 = CategoryTheory.CategoryStruct.comp a_1 f} {b_1 : D.obj i_1 ⟶ X}
{hb_1 : t.app i_1 = CategoryTheory.CategoryStruct.comp b_1 f}
{hab_1 :
CategoryTheory.CategoryStruct.comp (c_1.π.app i_1) a_1 = CategoryTheory.CategoryStruct.comp (c_1.π.app i_1) b_1}
{𝒰S_1 : S.OpenCover} {h𝒰S_1 : ∀ (i : 𝒰S_1.I₀), AlgebraicGeometry.IsAffine (𝒰S_1.X i)}
{𝒰X_1 :
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S_1).I₀) →
((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S_1).X i).OpenCover}
{h𝒰X_1 :
∀ (i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S_1).I₀) (j : (𝒰X_1 i).I₀),
AlgebraicGeometry.IsAffine ((𝒰X_1 i).X j)},
{ c := c, hc := hc, i := i, a := a, ha := ha, b := b, hb := hb, hab := hab, 𝒰S := 𝒰S, h𝒰S := h𝒰S, 𝒰X := 𝒰X,
h𝒰X := h𝒰X } =
{ c := c_1, hc := hc_1, i := i_1, a := a_1, ha := ha_1, b := b_1, hb := hb_1, hab := hab_1, 𝒰S := 𝒰S_1,
h𝒰S := h𝒰S_1, 𝒰X := 𝒰X_1, h𝒰X := h𝒰X_1 } →
c = c_1 ∧ hc ≍ hc_1 ∧ i = i_1 ∧ a ≍ a_1 ∧ b ≍ b_1 ∧ 𝒰S = 𝒰S_1 ∧ 𝒰X ≍ 𝒰X_1 | true |
Function.FromTypes.uncurry_apply_cons | Mathlib.Data.Fin.Tuple.Curry | ∀ {n : ℕ} {α : Type u} {p : Fin n → Type u} {τ : Type u} (f : Function.FromTypes (Matrix.vecCons α p) τ) (a : α)
(args : (i : Fin n) → p i), f.uncurry (Fin.cons a args) = (f a).uncurry args | true |
Array.«_aux_Init_Data_Array_Perm___macroRules_Array_term_~__1» | Init.Data.Array.Perm | Lean.Macro | false |
QuasispectrumRestricts.nonUnitalStarAlgHom._proof_19 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_3} {A : Type u_2} [inst : Semifield R] [inst_1 : TopologicalSpace R] [inst_2 : Field S]
[inst_3 : TopologicalSpace S] [inst_4 : NonUnitalRing A] [inst_5 : Algebra R S] [inst_6 : Module R A]
[inst_7 : Module S A] [inst_8 : IsScalarTower S A A] [inst_9 : SMulCommClass S A A] [inst_10 : IsScalarTower R S A]
{a : A} {f : C(S, R)} (h : QuasispectrumRestricts a ⇑f), { toFun := Subtype.map ⇑f ⋯, continuous_toFun := ⋯ } 0 = 0 | false |
Monotone.rightLim | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
[inst_2 : TopologicalSpace β] [OrderTopology β] {f : α → β}, Monotone f → Monotone (Function.rightLim f) | true |
Lean.Meta.Grind.instInhabitedCasesTypes | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.CasesTypes | true |
Aesop.RuleTac.tacGen | Aesop.RuleTac.Tactic | Lean.Name → Aesop.RuleTac | true |
Polynomial.SplittingField.instGroupWithZero._proof_3 | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type u_1} [inst : Field K] (f : Polynomial K) (n : ℕ) (a : f.SplittingField),
zpowRec npowRec (↑n.succ) a = zpowRec npowRec (↑n) a * a | false |
Lean.Omega.Int.mul_congr | Init.Omega.Int | ∀ {a b c d : ℤ}, a = b → c = d → a * c = b * d | true |
Ord.ext | Init.Data.Ord.Basic | ∀ {α : Type u} {x y : Ord α}, compare = compare → x = y | true |
SpectrumRestricts.nnreal_add | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ∀ {A : Type u_1} [inst : CStarAlgebra A] {a b : A},
IsSelfAdjoint a →
IsSelfAdjoint b →
SpectrumRestricts a ⇑ContinuousMap.realToNNReal →
SpectrumRestricts b ⇑ContinuousMap.realToNNReal → SpectrumRestricts (a + b) ⇑ContinuousMap.realToNNReal | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.isOpen_A_with_param._simp_1_4 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | false |
_private.Aesop.Script.StructureStatic.0.Aesop.Script.structureStaticCore.go | Aesop.Script.StructureStatic | Aesop.Script.TacticState → Aesop.Script.StaticStructureM (List Aesop.Script.Step × Aesop.Script.TacticState) | true |
_private.Init.Data.List.Find.0.List.lookup_eq_some_iff._simp_1_2 | Init.Data.List.Find | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | false |
EReal.nsmul_eq_mul | Mathlib.Data.EReal.Operations | ∀ (n : ℕ) (x : EReal), n • x = ↑n * x | true |
_private.Init.Prelude.0.Lean.Macro.State.mk._flat_ctor | Init.Prelude | Lean.MacroScope → List (Lean.Name × String) → List Lean.Name → Lean.Macro.State | false |
ContinuousOn.cfc_nnreal._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | false |
Lean.Lsp.InitializeParams.initializationOptions?._default | Lean.Data.Lsp.InitShutdown | Option Lean.Lsp.InitializationOptions | false |
bot_lt_affineSpan._simp_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : Set P}, (⊥ < affineSpan k s) = s.Nonempty | false |
Matrix.toBilin._proof_1 | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁],
SMulCommClass R₁ R₁ (M₁ →ₗ[R₁] R₁) | false |
IsSelfAdjoint.eq_smul_self_of_isLocalExtrOn | Mathlib.Analysis.InnerProductSpace.Rayleigh | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {T : E →L[𝕜] E},
IsSelfAdjoint T →
∀ {x₀ : E}, IsLocalExtrOn T.reApplyInnerSelf (Metric.sphere 0 ‖x₀‖) x₀ → T x₀ = ↑(T.rayleighQuotient x₀) • x₀ | true |
Lean.Parser.Term.prop.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
RelIso.instFunLike._proof_1 | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop},
Function.Injective ((fun e => ⇑e) ∘ RelIso.toEquiv) | false |
MulChar.ringHomComp_pow | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommRing R'] {R'' : Type u_3} [inst_2 : CommRing R'']
(χ : MulChar R R') (f : R' →+* R'') (n : ℕ), χ.ringHomComp f ^ n = (χ ^ n).ringHomComp f | true |
ringChar | Mathlib.Algebra.CharP.Defs | (R : Type u_1) → [NonAssocSemiring R] → ℕ | true |
RingCon.unop | Mathlib.RingTheory.Congruence.Opposite | {R : Type u_1} → [inst : Add R] → [inst_1 : Mul R] → RingCon Rᵐᵒᵖ → RingCon R | true |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.norm_le_interp_of_mem_verticalClosedStrip₀₁'._simp_1_2 | Mathlib.Analysis.Complex.Hadamard | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
Pi.instAddTorsor._proof_1 | Mathlib.Algebra.AddTorsor.Basic | ∀ {I : Type u_1} {fg : I → Type u_3} [inst : (i : I) → AddGroup (fg i)] {fp : I → Type u_2}
[(i : I) → AddTorsor (fg i) (fp i)], Nonempty ((a : I) → fp a) | false |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.sle_iff_rotate_le_rotate._simp_1_15 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ {a b : ℕ}, (¬a ≤ b) = (b < a) | false |
_private.Lean.Util.Recognizers.0.Lean.Expr.eqOrIff?._sparseCasesOn_1 | Lean.Util.Recognizers | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
MeromorphicAt.neg_iff._simp_1 | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : 𝕜} {f : 𝕜 → E}, MeromorphicAt (-f) x = MeromorphicAt f x | false |
ProbabilityTheory.uniformOn_singleton | Mathlib.Probability.UniformOn | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [MeasurableSingletonClass Ω] (ω : Ω) (t : Set Ω)
[inst_2 : Decidable (ω ∈ t)], (ProbabilityTheory.uniformOn {ω}) t = if ω ∈ t then 1 else 0 | true |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.Tree.recOn | Mathlib.Tactic.FBinop | {motive : FBinopElab.Tree✝ → Sort u} →
(t : FBinopElab.Tree✝¹) →
((ref : Lean.Syntax) →
(infoTrees : Lean.PersistentArray Lean.Elab.InfoTree) →
(val : Lean.Expr) → motive (FBinopElab.Tree.term✝ ref infoTrees val)) →
((ref : Lean.Syntax) →
(f : Lean.Expr) →
(lhs rhs : FBinopElab.Tree✝²) → motive lhs → motive rhs → motive (FBinopElab.Tree.binop✝ ref f lhs rhs)) →
((macroName : Lean.Name) →
(stx stx' : Lean.Syntax) →
(nested : FBinopElab.Tree✝³) →
motive nested → motive (FBinopElab.Tree.macroExpansion✝ macroName stx stx' nested)) →
motive t | false |
Lean.mkLevelSuccEx | Lean.Level | Lean.Level → Lean.Level | true |
Vector.map_attachWith_eq_pmap | Init.Data.Vector.Attach | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {xs : Vector α n} {P : α → Prop} {H : ∀ a ∈ xs, P a} {f : { x // P x } → β},
Vector.map f (xs.attachWith P H) = Vector.pmap (fun a h => f ⟨a, ⋯⟩) xs ⋯ | true |
Lean.Meta.Grind.DelayedTheoremInstance.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{thm : Lean.Meta.Grind.EMatchTheorem} →
{proof prop : Lean.Expr} →
{generation : ℕ} →
{guards : List Lean.Meta.Grind.TheoremGuard} →
{thm' : Lean.Meta.Grind.EMatchTheorem} →
{proof' prop' : Lean.Expr} →
{generation' : ℕ} →
{guards' : List Lean.Meta.Grind.TheoremGuard} →
{ thm := thm, proof := proof, prop := prop, generation := generation, guards := guards } =
{ thm := thm', proof := proof', prop := prop', generation := generation', guards := guards' } →
(thm = thm' → proof = proof' → prop = prop' → generation = generation' → guards = guards' → P) → P | false |
ContinuousAlgHom.prodEquiv._proof_1 | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_4} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_2} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
{C : Type u_3} [inst_7 : Semiring C] [inst_8 : Algebra R C] [inst_9 : TopologicalSpace C],
Function.LeftInverse (fun f => ((ContinuousAlgHom.fst R B C).comp f, (ContinuousAlgHom.snd R B C).comp f)) fun f =>
f.1.prod f.2 | false |
BoundedContinuousFunction.extend._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] {δ : Type u_3}
[inst_2 : TopologicalSpace δ] (f : α ↪ δ) (g : BoundedContinuousFunction α β) (h : BoundedContinuousFunction δ β),
∃ C, ∀ (x y : δ), dist (Function.extend (⇑f) (⇑g) (⇑h) x) (Function.extend (⇑f) (⇑g) (⇑h) y) ≤ C | false |
Equiv.Perm.two_le_length_toList_iff_mem_support | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {p : Equiv.Perm α} {x : α},
2 ≤ (p.toList x).length ↔ x ∈ p.support | true |
ValuationSubring.valuation_le_one_iff | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (x : K), A.valuation x ≤ 1 ↔ x ∈ A | true |
WeierstrassCurve.a₃_of_isCharTwoJNeZeroNF | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {R : Type u_1} [inst : CommRing R] (W : WeierstrassCurve R) [W.IsCharTwoJNeZeroNF], W.a₃ = 0 | true |
Lean.Meta.DiscrTree.Key.lit.injEq | Lean.Meta.DiscrTree.Types | ∀ (a a_1 : Lean.Literal), (Lean.Meta.DiscrTree.Key.lit a = Lean.Meta.DiscrTree.Key.lit a_1) = (a = a_1) | true |
Int8.instNeg | Init.Data.SInt.Basic | Neg Int8 | true |
AlgebraicIndependent.aevalEquiv | Mathlib.RingTheory.AlgebraicIndependent.Defs | {ι : Type u_1} →
{R : Type u_3} →
{A : Type u_5} →
{x : ι → A} →
[inst : CommRing R] →
[inst_1 : CommRing A] →
[inst_2 : Algebra R A] → AlgebraicIndependent R x → MvPolynomial ι R ≃ₐ[R] ↥(Algebra.adjoin R (Set.range x)) | true |
Equiv.sigmaFiberEquiv.match_1 | Mathlib.Logic.Equiv.Sum | ∀ {α : Type u_2} {β : Type u_1} (f : α → β) (motive : (y : β) × { x // f x = y } → Prop)
(x : (y : β) × { x // f x = y }), (∀ (a : α), motive ⟨f a, ⟨a, ⋯⟩⟩) → motive x | false |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.visitApp.match_1 | Lean.Meta.LetToHave | (motive : Lean.Expr → Sort u_1) →
(fType : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((x : Lean.Expr) → motive x) → motive fType | false |
FinBddDistLat.instBoundedOrderCarrier | Mathlib.Order.Category.FinBddDistLat | (X : FinBddDistLat) → BoundedOrder ↑X.toDistLat | true |
LaurentSeries.powerSeriesPart_eq_zero._simp_1 | Mathlib.RingTheory.LaurentSeries | ∀ {R : Type u_1} [inst : Semiring R] (x : LaurentSeries R), (x.powerSeriesPart = 0) = (x = 0) | false |
Std.Internal.List.self_le_maxKey_insertEntry | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {v : β k}, (compare k (Std.Internal.List.maxKey (Std.Internal.List.insertEntry k v l) ⋯)).isLE = true | true |
CategoryTheory.Localization.HasProductsOfShapeAux.isLimitMapCone._proof_2 | Mathlib.CategoryTheory.Localization.FiniteProducts | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [inst_2 : L.IsLocalization W] (J : Type)
[inst_3 : CategoryTheory.Limits.HasProductsOfShape J C] [inst_4 : W.IsStableUnderProductsOfShape J]
[inst_5 : W.ContainsIdentities] [inst_6 : Finite J] (F : CategoryTheory.Functor (CategoryTheory.Discrete J) C)
(j : CategoryTheory.Discrete J),
(CategoryTheory.Limits.coneOfAdj (CategoryTheory.Localization.HasProductsOfShapeAux.adj L W J) (F.comp L)).π.app j =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Localization.HasProductsOfShapeAux.compLimitFunctorIso L W J).app F).hom
((L.mapCone (CategoryTheory.Limits.limit.cone F)).π.app j) | false |
MeasurableEquiv.symm_vadd | Mathlib.MeasureTheory.Group.MeasurableEquiv | ∀ {G : Type u_1} {α : Type u_3} [inst : MeasurableSpace α] [inst_1 : AddGroup G] [inst_2 : AddAction G α]
[inst_3 : MeasurableConstVAdd G α] (c : G), (MeasurableEquiv.vadd c).symm = MeasurableEquiv.vadd (-c) | true |
Lean.Server.ServerTask.BaseIO.mapTaskCostly | Lean.Server.ServerTask | {α : Type u_1} → {β : Type} → (α → BaseIO β) → Lean.Server.ServerTask α → BaseIO (Lean.Server.ServerTask β) | true |
Lean.Meta.LazyDiscrTree.buildPath._unsafe_rec | Lean.Meta.LazyDiscrTree | (Bool → Array Lean.Expr → Lean.Expr → Lean.MetaM (Lean.Meta.LazyDiscrTree.Key × Array Lean.Expr)) →
Bool → Array Lean.Expr → Array Lean.Meta.LazyDiscrTree.Key → Lean.MetaM (Array Lean.Meta.LazyDiscrTree.Key) | false |
Lean.Elab.Tactic.RCases.RCasesPatt.brecOn | Lean.Elab.Tactic.RCases | {motive_1 : Lean.Elab.Tactic.RCases.RCasesPatt → Sort u} →
{motive_2 : List Lean.Elab.Tactic.RCases.RCasesPatt → Sort u} →
(t : Lean.Elab.Tactic.RCases.RCasesPatt) →
((t : Lean.Elab.Tactic.RCases.RCasesPatt) → t.below → motive_1 t) →
((t : List Lean.Elab.Tactic.RCases.RCasesPatt) → Lean.Elab.Tactic.RCases.RCasesPatt.below_1 t → motive_2 t) →
motive_1 t | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.isLevelDefEqS.match_1._arg_pusher | Lean.Meta.Sym.Pattern | ∀ (motive : Lean.Level → Lean.Level → Sort u_1) (α : Sort u✝) (β : α → Sort v✝) (f : (x : α) → β x)
(rel : Lean.Level → Lean.Level → α → Prop) (u v : Lean.Level)
(h_1 :
(u v : Lean.Name) →
((y : α) → rel (Lean.Level.param u) (Lean.Level.param v) y → β y) →
motive (Lean.Level.param u) (Lean.Level.param v))
(h_2 : Unit → ((y : α) → rel Lean.Level.zero Lean.Level.zero y → β y) → motive Lean.Level.zero Lean.Level.zero)
(h_3 : (u v : Lean.Level) → ((y : α) → rel u.succ v.succ y → β y) → motive u.succ v.succ)
(h_4 : (a : Lean.Level) → ((y : α) → rel Lean.Level.zero a.succ y → β y) → motive Lean.Level.zero a.succ)
(h_5 : (a : Lean.Level) → ((y : α) → rel a.succ Lean.Level.zero y → β y) → motive a.succ Lean.Level.zero)
(h_6 :
(v₁ v₂ : Lean.Level) → ((y : α) → rel Lean.Level.zero (v₁.max v₂) y → β y) → motive Lean.Level.zero (v₁.max v₂))
(h_7 :
(u₁ u₂ : Lean.Level) → ((y : α) → rel (u₁.max u₂) Lean.Level.zero y → β y) → motive (u₁.max u₂) Lean.Level.zero)
(h_8 : (a v : Lean.Level) → ((y : α) → rel Lean.Level.zero (a.imax v) y → β y) → motive Lean.Level.zero (a.imax v))
(h_9 : (a u : Lean.Level) → ((y : α) → rel (a.imax u) Lean.Level.zero y → β y) → motive (a.imax u) Lean.Level.zero)
(h_10 : (u₁ u₂ v₁ v₂ : Lean.Level) → ((y : α) → rel (u₁.max u₂) (v₁.max v₂) y → β y) → motive (u₁.max u₂) (v₁.max v₂))
(h_11 :
(u₁ u₂ v₁ v₂ : Lean.Level) → ((y : α) → rel (u₁.imax u₂) (v₁.imax v₂) y → β y) → motive (u₁.imax u₂) (v₁.imax v₂))
(h_12 : (x x_1 : Lean.Level) → ((y : α) → rel x x_1 y → β y) → motive x x_1),
((match (motive := (u v : Lean.Level) → ((y : α) → rel u v y → β y) → motive u v) u, v with
| Lean.Level.param u, Lean.Level.param v => fun x => h_1 u v x
| Lean.Level.zero, Lean.Level.zero => fun x => h_2 a x
| u.succ, v.succ => fun x => h_3 u v x
| Lean.Level.zero, a.succ => fun x => h_4 a x
| a.succ, Lean.Level.zero => fun x => h_5 a x
| Lean.Level.zero, v₁.max v₂ => fun x => h_6 v₁ v₂ x
| u₁.max u₂, Lean.Level.zero => fun x => h_7 u₁ u₂ x
| Lean.Level.zero, a.imax v => fun x => h_8 a v x
| a.imax u, Lean.Level.zero => fun x => h_9 a u x
| u₁.max u₂, v₁.max v₂ => fun x => h_10 u₁ u₂ v₁ v₂ x
| u₁.imax u₂, v₁.imax v₂ => fun x => h_11 u₁ u₂ v₁ v₂ x
| x, x_1 => fun x_2 => h_12 x x_1 x_2)
fun y h => f y) =
match u, v with
| Lean.Level.param u, Lean.Level.param v => h_1 u v fun y h => f y
| Lean.Level.zero, Lean.Level.zero => h_2 a fun y h => f y
| u.succ, v.succ => h_3 u v fun y h => f y
| Lean.Level.zero, a.succ => h_4 a fun y h => f y
| a.succ, Lean.Level.zero => h_5 a fun y h => f y
| Lean.Level.zero, v₁.max v₂ => h_6 v₁ v₂ fun y h => f y
| u₁.max u₂, Lean.Level.zero => h_7 u₁ u₂ fun y h => f y
| Lean.Level.zero, a.imax v => h_8 a v fun y h => f y
| a.imax u, Lean.Level.zero => h_9 a u fun y h => f y
| u₁.max u₂, v₁.max v₂ => h_10 u₁ u₂ v₁ v₂ fun y h => f y
| u₁.imax u₂, v₁.imax v₂ => h_11 u₁ u₂ v₁ v₂ fun y h => f y
| x, x_1 => h_12 x x_1 fun y h => f y | false |
AdjoinRoot.quotEquivQuotMap_symm_apply_mk | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (I : Ideal R),
(AdjoinRoot.quotEquivQuotMap f I).symm
((Ideal.Quotient.mk (Ideal.span {Polynomial.map (Ideal.Quotient.mk I) f}))
(Polynomial.map (Ideal.Quotient.mk I) g)) =
(Ideal.Quotient.mk (Ideal.map (AdjoinRoot.of f) I)) ((AdjoinRoot.mk f) g) | true |
StarMonoidHom.mk.noConfusion | Mathlib.Algebra.Star.MonoidHom | {A : Type u_6} →
{B : Type u_7} →
{inst : Monoid A} →
{inst_1 : Star A} →
{inst_2 : Monoid B} →
{inst_3 : Star B} →
{P : Sort u} →
{toMonoidHom : A →* B} →
{map_star' : ∀ (a : A), (↑toMonoidHom).toFun (star a) = star ((↑toMonoidHom).toFun a)} →
{toMonoidHom' : A →* B} →
{map_star'' : ∀ (a : A), (↑toMonoidHom').toFun (star a) = star ((↑toMonoidHom').toFun a)} →
{ toMonoidHom := toMonoidHom, map_star' := map_star' } =
{ toMonoidHom := toMonoidHom', map_star' := map_star'' } →
(toMonoidHom ≍ toMonoidHom' → P) → P | false |
AlgebraicGeometry.Scheme.Pullback.gluing_V | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(x : 𝒰.I₀ × 𝒰.I₀),
(AlgebraicGeometry.Scheme.Pullback.gluing 𝒰 f g).V x =
match x with
| (i, j) => AlgebraicGeometry.Scheme.Pullback.v 𝒰 f g i j | true |
TensorProduct.exists_finite_submodule_of_setFinite' | Mathlib.LinearAlgebra.TensorProduct.Finiteness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {M₁ : Submodule R M} {N₁ : Submodule R N}
(s : Set (TensorProduct R ↥M₁ ↥N₁)),
s.Finite →
∃ M' N',
∃ (hM : M' ≤ M₁) (hN : N' ≤ N₁),
Module.Finite R ↥M' ∧
Module.Finite R ↥N' ∧ s ⊆ ↑(TensorProduct.map (Submodule.inclusion hM) (Submodule.inclusion hN)).range | true |
IntermediateField.one_mem'._inherited_default | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} {inst : Field K} {inst_1 : Field L} {inst_2 : Algebra K L} (carrier : Set L),
(∀ (r : K), (algebraMap K L) r ∈ carrier) → 1 ∈ carrier | false |
Lean.Meta.Grind.Order.mkPropagateEqTrueProof | Lean.Meta.Tactic.Grind.Order.Proof | Lean.Expr →
Lean.Expr →
Lean.Meta.Grind.Order.Weight → Lean.Expr → Lean.Meta.Grind.Order.Weight → Lean.Meta.Grind.Order.OrderM Lean.Expr | true |
Lean.Meta.Simp.ConfigCtx.unfoldPartialApp._inherited_default | Init.MetaTypes | Bool | false |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.comap_monotone._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
Std.DTreeMap.Internal.Impl.Const.entryAtIdx.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : Type u_2} →
(motive : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.Balanced → (x_2 : ℕ) → x_2 < x.size → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α fun x => β) →
(x_1 : x.Balanced) →
(x_2 : ℕ) →
(x_3 : x_2 < x.size) →
((size : ℕ) →
(k : α) →
(v : β) →
(l' r' : Std.DTreeMap.Internal.Impl α fun x => β) →
(hl : (Std.DTreeMap.Internal.Impl.inner size k v l' r').Balanced) →
(n : ℕ) →
(h : n < (Std.DTreeMap.Internal.Impl.inner size k v l' r').size) →
motive (Std.DTreeMap.Internal.Impl.inner size k v l' r') hl n h) →
motive x x_1 x_2 x_3 | false |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.summable_jacobiTheta₂'_term_iff._simp_1_3 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ (n : ℤ), ↑n = ↑↑n | false |
_private.Mathlib.CategoryTheory.Monoidal.Bimod.0.Bimod.id_whiskerLeft_bimod._proof_1_1 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C] {X Y : CategoryTheory.Mon C} {N : Bimod X Y},
CategoryTheory.Limits.HasColimit
(CategoryTheory.Limits.parallelPair
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
{ X := X.X, actLeft := CategoryTheory.MonObj.mul, one_actLeft := ⋯, left_assoc := ⋯,
actRight := CategoryTheory.MonObj.mul, actRight_one := ⋯, right_assoc := ⋯, middle_assoc := ⋯ }.actRight
N.X)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator
{ X := X.X, actLeft := CategoryTheory.MonObj.mul, one_actLeft := ⋯, left_assoc := ⋯,
actRight := CategoryTheory.MonObj.mul, actRight_one := ⋯, right_assoc := ⋯, middle_assoc := ⋯ }.X
X.X N.X).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft
{ X := X.X, actLeft := CategoryTheory.MonObj.mul, one_actLeft := ⋯, left_assoc := ⋯,
actRight := CategoryTheory.MonObj.mul, actRight_one := ⋯, right_assoc := ⋯, middle_assoc := ⋯ }.X
N.actLeft))) | false |
Field.toEuclideanDomain.match_1 | Mathlib.Algebra.EuclideanDomain.Field | ∀ {K : Type u_1} [inst : Field K] (x x_1 : K) (motive : x_1 = 0 ∧ x ≠ 0 → Prop) (x_2 : x_1 = 0 ∧ x ≠ 0),
(∀ (left : x_1 = 0) (hnb : x ≠ 0), motive ⋯) → motive x_2 | false |
Int.Linear.Poly.mul' | Init.Data.Int.Linear | Int.Linear.Poly → ℤ → Int.Linear.Poly | true |
_private.Mathlib.Tactic.ComputeDegree.0.Mathlib.Tactic.ComputeDegree.dispatchLemma.match_1 | Mathlib.Tactic.ComputeDegree | (motive : Lean.Name → Lean.Name → Sort u_1) →
(na1 na2 : Lean.Name) →
(Unit → motive `Polynomial.natDegree `LE.le) →
(Unit → motive `Polynomial.degree `LE.le) →
(Unit → motive `Polynomial.coeff `Eq) →
((x : Lean.Name) → motive x `LE.le) → ((x x_1 : Lean.Name) → motive x x_1) → motive na1 na2 | false |
Order.Ideal.instLattice | Mathlib.Order.Ideal | {P : Type u_1} → [inst : SemilatticeSup P] → [IsCodirectedOrder P] → Lattice (Order.Ideal P) | true |
Submodule.existsUnique_add_of_isCompl | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E},
IsCompl p q → ∀ (x : E), ∃ u v, ↑u + ↑v = x ∧ ∀ (r : ↥p) (s : ↥q), ↑r + ↑s = x → r = u ∧ s = v | true |
MonoidHom.coe_ofClosureMEqTopRight | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N] {s : Set M} (f : M → N)
(hs : Submonoid.closure s = ⊤) (h1 : f 1 = 1) (hmul : ∀ (x y : M), y ∈ s → f (x * y) = f x * f y),
⇑(MonoidHom.ofClosureMEqTopRight f hs h1 hmul) = f | true |
Std.TreeSet.inter_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp}, t₁.inter t₂ = t₁ ∩ t₂ | true |
Std.DHashMap.Internal.Raw.inter_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} (h₁ : m₁.WF)
(h₂ : m₂.WF), m₁.inter m₂ = ↑(Std.DHashMap.Internal.Raw₀.inter ⟨m₁, ⋯⟩ ⟨m₂, ⋯⟩) | true |
_private.Lean.Meta.InferType.0.Lean.Meta.isArrowProposition'.checkProp._sunfold | Lean.Meta.InferType | Lean.Expr → Lean.Meta.ArrowPropResult✝ | false |
Pointed.Hom.instInhabited | Mathlib.CategoryTheory.Category.Pointed | (X : Pointed) → Inhabited (X.Hom X) | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Operations.0.contDiff_pi._simp_1_2 | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {n : WithTop ℕ∞} {ι : Type u_3} [inst_3 : Fintype ι] {F' : ι → Type u_5}
[inst_4 : (i : ι) → NormedAddCommGroup (F' i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i},
ContDiffOn 𝕜 n Φ s = ∀ (i : ι), ContDiffOn 𝕜 n (fun x => Φ x i) s | false |
Std.HashSet.Raw.get?_of_isEmpty | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α],
m.WF → ∀ {a : α}, m.isEmpty = true → m.get? a = none | true |
existsUnique_eq._simp_1 | Mathlib.Logic.ExistsUnique | ∀ {α : Sort u_1} {a' : α}, (∃! a, a = a') = True | false |
ModuleCat.semilinearMapAddEquiv | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : Ring R] →
[inst_1 : Ring S] →
(f : R →+* S) →
(M : ModuleCat R) → (N : ModuleCat S) → (↑M →ₛₗ[f] ↑N) ≃+ (M ⟶ (ModuleCat.restrictScalars f).obj N) | true |
CategoryTheory.IsKernelPair.lift' | Mathlib.CategoryTheory.Limits.Shapes.KernelPair | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{R X Y : C} →
{f : X ⟶ Y} →
{a b : R ⟶ X} →
{S : C} →
CategoryTheory.IsKernelPair f a b →
(p q : S ⟶ X) →
CategoryTheory.CategoryStruct.comp p f = CategoryTheory.CategoryStruct.comp q f →
{ t // CategoryTheory.CategoryStruct.comp t a = p ∧ CategoryTheory.CategoryStruct.comp t b = q } | true |
QuaternionAlgebra.equivTuple._proof_2 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} (c₁ c₂ c₃ : R) (x : Fin 4 → R),
(fun a => ![a.re, a.imI, a.imJ, a.imK]) ((fun a => { re := a 0, imI := a 1, imJ := a 2, imK := a 3 }) x) = x | false |
MeasureTheory.Measure.toSignedMeasure_toMeasureOfZeroLE | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) [inst : MeasureTheory.IsFiniteMeasure μ],
μ.toSignedMeasure.toMeasureOfZeroLE Set.univ ⋯ ⋯ = μ | true |
MDifferentiableWithinAt.congr_nhds | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {x : M} {s : Set M},
MDiffAt[s] f x → ∀ {t : Set M}, nhdsWithin x s = nhdsWithin x t → MDiffAt[t] f x | true |
WeakDual.CharacterSpace.continuousMapEval._proof_8 | Mathlib.Topology.ContinuousMap.Ideals | ∀ (X : Type u_1) (𝕜 : Type u_2) [inst : TopologicalSpace X] [inst_1 : CommRing 𝕜] [inst_2 : TopologicalSpace 𝕜]
[inst_3 : IsTopologicalRing 𝕜] (x : X) (x_1 : 𝕜) (x_2 : C(X, 𝕜)), (x_1 • x_2) x = (x_1 • x_2) x | false |
List.getLast_append_right._proof_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l' l : List α}, l' ≠ [] → l ++ l' = [] → False | false |
List.Vector.snoc_cons | Mathlib.Data.Vector.Snoc | ∀ {α : Type u_1} {n : ℕ} {x : α} (xs : List.Vector α n) {y : α}, (x ::ᵥ xs).snoc y = x ::ᵥ xs.snoc y | true |
BitVec.getMsbD_ofBoolListLE | Init.Data.BitVec.Lemmas | ∀ {bs : List Bool} {i : ℕ},
(BitVec.ofBoolListLE bs).getMsbD i = (decide (i < bs.length) && bs.getD (bs.length - 1 - i) false) | true |
HomologicalComplex₂.toGradedObject.match_1 | Mathlib.Algebra.Homology.HomologicalBicomplex | {I₁ : Type u_1} →
{I₂ : Type u_2} → (motive : I₁ × I₂ → Sort u_3) → (x : I₁ × I₂) → ((i₁ : I₁) → (i₂ : I₂) → motive (i₁, i₂)) → motive x | false |
GroupLike.instGroup._proof_5 | Mathlib.RingTheory.HopfAlgebra.GroupLike | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : HopfAlgebra R A]
(a : GroupLike R A), a⁻¹ * a = 1 | false |
ContinuousMultilinearMap.recOn | Mathlib.Topology.Algebra.Module.Multilinear.Basic | {R : Type u} →
{ι : Type v} →
{M₁ : ι → Type w₁} →
{M₂ : Type w₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] →
[inst_4 : Module R M₂] →
[inst_5 : (i : ι) → TopologicalSpace (M₁ i)] →
[inst_6 : TopologicalSpace M₂] →
{motive : ContinuousMultilinearMap R M₁ M₂ → Sort u_1} →
(t : ContinuousMultilinearMap R M₁ M₂) →
((toMultilinearMap : MultilinearMap R M₁ M₂) →
(cont : Continuous toMultilinearMap.toFun) →
motive { toMultilinearMap := toMultilinearMap, cont := cont }) →
motive t | false |
Nat.multichoose_succ_succ | Mathlib.Data.Nat.Choose.Basic | ∀ (n k : ℕ), (n + 1).multichoose (k + 1) = n.multichoose (k + 1) + (n + 1).multichoose k | true |
ProbabilityTheory.Kernel.piecewise.congr_simp | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {s s_1 : Set α} (e_s : s = s_1)
{inst : DecidablePred fun x => x ∈ s} [inst_1 : DecidablePred fun x => x ∈ s_1] (hs : MeasurableSet s)
(κ κ_1 : ProbabilityTheory.Kernel α β),
κ = κ_1 →
∀ (η η_1 : ProbabilityTheory.Kernel α β),
η = η_1 → ProbabilityTheory.Kernel.piecewise hs κ η = ProbabilityTheory.Kernel.piecewise ⋯ κ_1 η_1 | true |
_private.Lean.Elab.PreDefinition.Structural.FindRecArg.0.Lean.Elab.Structural.argsInGroup.match_5 | Lean.Elab.PreDefinition.Structural.FindRecArg | (motive : Option (ℕ × Std.Iter ℕ) → Sort u_1) →
(x : Option (ℕ × Std.Iter ℕ)) →
(Unit → motive none) → ((indIdx : ℕ) → (s' : Std.Iter ℕ) → motive (some (indIdx, s'))) → motive x | false |
instNontrivialFreeRing | Mathlib.RingTheory.FreeRing | ∀ (α : Type u_1), Nontrivial (FreeRing α) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.