name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.PreGaloisCategory.PointedGaloisObject.noConfusionType | Mathlib.CategoryTheory.Galois.Prorepresentability | Sort u →
{C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
{F : CategoryTheory.Functor C FintypeCat} →
CategoryTheory.PreGaloisCategory.PointedGaloisObject F →
{C' : Type u₁} →
[inst' : CategoryTheory.Catego... | null | false |
_private.Mathlib.RingTheory.Support.0.Module.support_subset_of_injective._simp_1_1 | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{p : PrimeSpectrum R}, (p ∈ Module.support R M) = ∃ m, ∀ r ∉ p.asIdeal, r • m ≠ 0 | null | false |
SubtractionCommMonoid.casesOn | Mathlib.Algebra.Group.DivInvMonoid | {G : Type u_2} →
{motive : SubtractionCommMonoid G → Sort u} →
(t : SubtractionCommMonoid G) →
([toSubtractionMonoid : SubtractionMonoid G] →
(add_comm : ∀ (a b : G), a + b = b + a) →
motive { toSubtractionMonoid := toSubtractionMonoid, add_comm := add_comm }) →
motive t | null | false |
SSet.N.cast._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} (s : X.N) {d : ℕ} (hd : s.dim = d), (s.cast hd).simplex ∈ X.nonDegenerate (s.cast hd).dim | null | false |
ProofWidgets.instToJsonMakeEditLinkProps | ProofWidgets.Component.MakeEditLink | Lean.ToJson ProofWidgets.MakeEditLinkProps | null | true |
Aesop.instInhabitedNormSimpContext | Aesop.Search.SearchM | Inhabited Aesop.NormSimpContext | null | true |
Colex.instGroup | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [Group α] → Group (Colex α) | null | true |
Filter.Germ.abs_def | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {β : Type v} {φ : Ultrafilter α} [inst : AddCommGroup β] [inst_1 : LinearOrder β] (x : (↑φ).Germ β),
|x| = Filter.Germ.map abs x | null | true |
Mathlib.Tactic.Order.AtomicFact.nle.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (lhs rhs : ℕ) (proof : Lean.Expr),
sizeOf (Mathlib.Tactic.Order.AtomicFact.nle lhs rhs proof) = 1 + sizeOf lhs + sizeOf rhs + sizeOf proof | null | true |
Int.pow_gcd_pow | Init.Data.Int.Gcd | ∀ {n m : ℤ} {k : ℕ}, (n ^ k).gcd (m ^ k) = n.gcd m ^ k | null | true |
_private.Mathlib.Tactic.Linter.Whitespace.0.Mathlib.Linter.Style.Whitespace.getUnlintedRanges.match_1 | Mathlib.Tactic.Linter.Whitespace | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) →
((trail : Lean.Syntax.Range) → motive (some trail)) → ((x : Option Lean.Syntax.Range) → motive x) → motive x | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_modify._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Interval.commMonoid | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_2} → [inst : CommMonoid α] → [inst_1 : Preorder α] → [IsOrderedMonoid α] → CommMonoid (Interval α) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.InvLog.0.Real.not_differentiableAt_inv_log_zero._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Log.InvLog | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, DifferentiableAt 𝕜 f x = HasDerivAt f (deriv f x) x | null | false |
instMulSemiringActionQuotientSubgroupSubtypeMemSubalgebraSubalgebra._proof_8 | Mathlib.RingTheory.Invariant.Basic | ∀ {A : Type u_3} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {G : Type u_1}
[inst_3 : Group G] [inst_4 : MulSemiringAction G B] [inst_5 : SMulCommClass G A B] (H : Subgroup G)
[inst_6 : H.Normal] (g : G ⧸ H) (x y : ↥(FixedPoints.subalgebra A B ↥H)), g • (x * y) = g • x * g • y | null | false |
HasCardinalLT.Set.isColimitCocone._proof_2 | Mathlib.CategoryTheory.Presentable.Type | ∀ (X : Type u_1) (κ : Cardinal.{u_1}),
CategoryTheory.IsFiltered (HasCardinalLT.Set X κ) → CategoryTheory.IsFilteredOrEmpty (HasCardinalLT.Set X κ) | null | false |
MeasureTheory.intervalIntegral_integral_swap | Mathlib.MeasureTheory.Integral.Prod | ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [MeasureTheory.SFinite μ] {a b : ℝ} {f : ℝ → α → E},
MeasureTheory.Integrable (Function.uncurry f) ((MeasureTheory.volume.restrict (Set.uIoc a b)).prod μ) →
∫ (x : ... | Change the order of integration, when one of the integrals is an interval integral. | true |
MonCat.FilteredColimits.colimitMulOneClass._proof_1 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J MonCat)
[inst_1 : CategoryTheory.IsFiltered J] (x : MonCat.FilteredColimits.M F), 1 * x = x | null | false |
CategoryTheory.StructuredArrow.preEquivalenceFunctor._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_5}
[inst_1 : CategoryTheory.Category.{u_2, u_5} D] {E : Type u_6} [inst_2 : CategoryTheory.Category.{u_4, u_6} E]
(F : CategoryTheory.Functor C D) {G : CategoryTheory.Functor D E} {e : E} (f : CategoryTheory.StructuredArrow e G)
(X : Categ... | null | false |
Lean.Compiler.LCNF.PP.ppLetValue | Lean.Compiler.LCNF.PrettyPrinter | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.LetValue pu → Lean.Compiler.LCNF.PP.M Std.Format | null | true |
AddGroupExtension.Splitting.coe_addMonoidHom_mk | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : AddGroup N] [inst_1 : AddGroup E] [inst_2 : AddGroup G]
{S : AddGroupExtension N E G} (s : G →+ E) (hs : Function.RightInverse ⇑s ⇑S.rightHom),
↑{ toAddMonoidHom := s, rightInverse_rightHom := hs } = s | **Alias** of `AddGroupExtension.Splitting.toAddMonoidHom_mk`. | true |
CategoryTheory.Enriched.HasConicalLimitsOfSize.recOn | Mathlib.CategoryTheory.Enriched.Limits.HasConicalLimits | {V : Type u'} →
[inst : CategoryTheory.Category.{v', u'} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u} →
[inst_2 : CategoryTheory.Category.{v, u} C] →
[inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C] →
{motive : CategoryTheory.Enriched.HasConicalLimitsO... | null | false |
LieAlgebra.SemiDirectSum.instLieRing._proof_4 | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_3} [inst : CommRing R] {K : Type u_1} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_2}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K) (x x_1 x_2 : K ⋊⁅ψ⁆ L),
⁅x, x_1 + x_2⁆ = ⁅x, x_1⁆ + ⁅x, x_2⁆ | null | false |
GenLoop.continuous_fromLoop | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] (i : N),
Continuous (GenLoop.fromLoop i) | null | true |
AddRightReflectLE | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | (M : Type u_1) → [Add M] → [LE M] → Prop | Typeclass for reverse monotonicity of addition on the right,
namely `a₁ + b ≤ a₂ + b → a₁ ≤ a₂`.
You should usually not use this very granular typeclass directly, but rather a typeclass like
`IsOrderedCancelAddMonoid`. | true |
_private.Mathlib.NumberTheory.Height.MvPolynomial.0.Height.hasFiniteMulSupport_iSup_max_iSup_one._simp_1_1 | Mathlib.NumberTheory.Height.MvPolynomial | ∀ {α : Type u_1} {M : Type u_2} [inst : One M], (Function.HasFiniteMulSupport fun x => 1) = True | null | false |
Lean.ModuleData.mk.inj | Lean.Environment | ∀ {isModule : Bool} {imports : Array Lean.Import} {constNames : Array Lean.Name} {constants : Array Lean.ConstantInfo}
{extraConstNames : Array Lean.Name} {entries : Array (Lean.Name × Array Lean.EnvExtensionEntry)} {isModule_1 : Bool}
{imports_1 : Array Lean.Import} {constNames_1 : Array Lean.Name} {constants_1 : ... | null | true |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal.go._unary._proof_2 | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : ℤ), acc + 1 - acc = 1 | null | false |
Sublattice.map_map | Mathlib.Order.Sublattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : Lattice γ]
{L : Sublattice α} (g : LatticeHom β γ) (f : LatticeHom α β),
Sublattice.map g (Sublattice.map f L) = Sublattice.map (g.comp f) L | null | true |
_private.Mathlib.NumberTheory.Height.NumberField.0.NumberField.exists_nat_ne_zero_exists_integer_mul_eq_and_absNorm_span_eq_pow._proof_1_3 | Mathlib.NumberTheory.Height.NumberField | ∀ {K : Type u_1} [inst : Field K] (m : ℕ) (r : NumberField.RingOfIntegers K), r ∈ {↑m, r} | null | false |
SModEq.sub | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {U : Submodule R M}
{x₁ x₂ y₁ y₂ : M}, x₁ ≡ y₁ [SMOD U] → x₂ ≡ y₂ [SMOD U] → x₁ - x₂ ≡ y₁ - y₂ [SMOD U] | null | true |
Std.DTreeMap.Raw.Const.getKey?_filter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{f : α → β → Bool} {k : α} (h : t.WF),
(Std.DTreeMap.Raw.filter f t).getKey? k = (t.getKey? k).pfilter fun x h' => f x (Std.DTreeMap.Raw.Const.get t x ⋯) | null | true |
Lean.Expr.FoldConstsImpl.State.mk | Lean.Util.FoldConsts | Lean.PtrSet Lean.Expr → Lean.NameHashSet → Lean.Expr.FoldConstsImpl.State | null | true |
Lean.Elab.DocElabInfo.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} → {t t' : Lean.Elab.DocElabInfo} → t = t' → Lean.Elab.DocElabInfo.noConfusionType P t t' | null | false |
CategoryTheory.Codiscrete.unitApp | Mathlib.CategoryTheory.CodiscreteCategory | (C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Functor C (CategoryTheory.Codiscrete C) | Components of the unit of the adjunction `Cat.objects ⊣ Codiscrete.functorToCat`. | true |
lt_of_le_of_ne' | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b ≤ a → a ≠ b → b < a | null | true |
Int.add_modulus_mul_modEq_iff | Mathlib.Data.Int.ModEq | ∀ {n a b c : ℤ}, a + n * b ≡ c [ZMOD n] ↔ a ≡ c [ZMOD n] | null | true |
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.PosSemidef.natCast._simp_1_2 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{a : R}, 0 ≤ a → ∀ (c : R), (0 ≤ star c * a * c) = True | null | false |
QuadraticForm.tensorRId_symm_apply | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct.Isometries | ∀ {R : Type uR} {M₁ : Type uM₁} [inst : CommRing R] [inst_1 : AddCommGroup M₁] [inst_2 : Module R M₁]
[inst_3 : Invertible 2] (Q₁ : QuadraticForm R M₁) (x : M₁), Q₁.tensorRId.symm x = (TensorProduct.rid R M₁).symm x | null | true |
SSet.S.dim_eq_of_mk_eq | Mathlib.AlgebraicTopology.SimplicialSet.Simplices | ∀ {X : SSet} {n m : ℕ} {x : X.obj (Opposite.op { len := n })} {y : X.obj (Opposite.op { len := m })},
{ dim := n, simplex := x } = { dim := m, simplex := y } → n = m | null | true |
Sbtw.oangle₁₃₂_eq_zero | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P}, Sbtw ℝ p₁ p₂ p₃ → EuclideanGeometry.oangle p₁ p₃ p₂ = 0 | If the second of three points is strictly between the other two, the oriented angle at the
third point (reversed) is zero. | true |
CommRingCat.Colimits.Prequotient.of.sizeOf_spec | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat} [inst_1 : SizeOf J]
(j : J) (x : ↑(F.obj j)), sizeOf (CommRingCat.Colimits.Prequotient.of j x) = 1 + sizeOf j + sizeOf x | null | true |
MeasureTheory.L1.measurable_coeFn | Mathlib.MeasureTheory.Function.L1Space.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
[inst_1 : MeasurableSpace β] [BorelSpace β] (f : ↥(MeasureTheory.Lp β 1 μ)), Measurable ↑↑f | null | true |
CategoryTheory.EnrichedNatTrans.mk | Mathlib.CategoryTheory.Enriched.Basic | {V : Type v} →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
[inst_2 : CategoryTheory.EnrichedCategory V C] →
{D : Type u₂} →
[inst_3 : CategoryTheory.EnrichedCategory V D] →
{F G : CategoryTheory.Enrich... | null | true |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.horizontal_strip._simp_1_9 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b | null | false |
Matrix.mulVec_empty | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} {m' : Type uₘ} [inst : NonUnitalNonAssocSemiring α] (A : Matrix m' (Fin 0) α) (v : Fin 0 → α),
A.mulVec v = 0 | null | true |
DifferentiableOn.zpow | Mathlib.Analysis.Calculus.Deriv.ZPow | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type v} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {m : ℤ} {f : E → 𝕜} {t : Set E},
DifferentiableOn 𝕜 f t → (∀ x ∈ t, f x ≠ 0) ∨ 0 ≤ m → DifferentiableOn 𝕜 (fun x => f x ^ m) t | null | true |
Lat.ext | Mathlib.Order.Category.Lat | ∀ {X Y : Lat} {f g : X ⟶ Y},
(∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x) → f = g | null | true |
TruncatedWittVector.truncate_wittVector_truncate | Mathlib.RingTheory.WittVector.Truncated | ∀ {p n : ℕ} {R : Type u_1} [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] {m : ℕ} (hm : n ≤ m) (x : WittVector p R),
(TruncatedWittVector.truncate hm) ((WittVector.truncate m) x) = (WittVector.truncate n) x | null | true |
StarAlgHom.rangeRestrict | Mathlib.Algebra.Star.Subalgebra | {R : Type u_2} →
{A : Type u_3} →
{B : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : StarRing R] →
[inst_2 : Semiring A] →
[inst_3 : Algebra R A] →
[inst_4 : StarRing A] →
[inst_5 : Semiring B] →
[inst_6 : Algebra R B] →
... | Restriction of the codomain of a `StarAlgHom` to its range. | true |
_private.Lean.Elab.Tactic.Grind.Config.0.Lean.Elab.Tactic.elabGrindConfigCore | Lean.Elab.Tactic.Grind.Config | (Lean.Term → Lean.Elab.TermElabM Lean.Grind.Config) →
Lean.Syntax → optParam Lean.Grind.Config { } → optParam Bool true → Lean.Elab.TermElabM Lean.Grind.Config | Elaborator for grind configurations, with the `(config := ...)` elaborator exposed.
This allows overriding which structure is used as the expected type when elaborating
the term, which affects which default values are used in `{...}` structure instance notation.
| true |
CategoryTheory.LocalizerMorphism.LeftResolution.instCategory._proof_4 | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_2} {C₂ : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
{X Y : Φ.LeftResolution X₂} (f : X.Hom Y), f.... | null | false |
_private.Mathlib.Order.Interval.Set.UnorderedInterval.0.Set.monotoneOn_or_antitoneOn_iff_uIcc._simp_1_4 | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (a ∈ Set.uIcc b c) = (b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b) | null | false |
Int.Internal.Linear.cooper_right_split_ineq_cert | Init.Data.Int.Linear | Int.Internal.Linear.Poly → Int.Internal.Linear.Poly → ℤ → ℤ → Int.Internal.Linear.Poly → Bool | null | true |
_private.Mathlib.Tactic.TFAE.0.Mathlib.Tactic.TFAE._aux_Mathlib_Tactic_TFAE___elabRules_Mathlib_Tactic_TFAE_tfaeFinish_1._sparseCasesOn_3 | Mathlib.Tactic.TFAE | {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 | null | false |
RBTree.RBNode.IsMonotone.mk._flat_ctor | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} {β : Type u_2} {cmpα : α → α → Ordering} {cmpβ : β → β → Ordering} {f : α → β},
(∀ {x y : α}, RBTree.RBNode.cmpLT cmpα x y → RBTree.RBNode.cmpLT cmpβ (f x) (f y)) →
RBTree.RBNode.IsMonotone cmpα cmpβ f | null | false |
SkewPolynomial.support | Mathlib.Algebra.SkewPolynomial.Basic | {R : Type u_1} → [inst : Semiring R] → SkewPolynomial R → Finset ℕ | The set of all `n` such that `X^n` has a non-zero coefficient.
| true |
_private.Aesop.Tree.ExtractProof.0.Aesop.extractProofMVarCluster.match_1 | Aesop.Tree.ExtractProof | (motive : Option Aesop.GoalRef → Sort u_1) →
(gref? : Option Aesop.GoalRef) →
((gref : Aesop.GoalRef) → motive (some gref)) → ((x : Option Aesop.GoalRef) → motive x) → motive gref? | null | false |
Set.subset_range_of_surjective | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Surjective f → ∀ (s : Set β), s ⊆ Set.range f | null | true |
CategoryTheory.Quotient.LiftCommShift.iso_hom_app | Mathlib.CategoryTheory.Shift.Quotient | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : CategoryTheory.Functor C D) (r : HomRel C) {A : Type w} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : r.IsCompatibleWithShift A]
... | null | true |
MeasureTheory.sub_eq_zero_of_upcrossingsBefore_lt | Mathlib.Probability.Martingale.Upcrossing | ∀ {Ω : Type u_1} {a b : ℝ} {f : ℕ → Ω → ℝ} {N n : ℕ} {ω : Ω},
a < b →
MeasureTheory.upcrossingsBefore a b f N ω < n →
MeasureTheory.stoppedValue f (fun ω => ↑(MeasureTheory.upperCrossingTime a b f N (n + 1) ω)) ω -
MeasureTheory.stoppedValue f (fun ω => ↑(MeasureTheory.lowerCrossingTime a b f N n ... | null | true |
IsGaloisGroup.normal_of_isGalois | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (K : Type u_3) (L : Type u_4) [inst : Group G] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] [inst_4 : MulSemiringAction G L] (H : Subgroup G) [hGKL : IsGaloisGroup G K L] (E : Type u_5)
[inst_5 : Field E] [inst_6 : Algebra K E] [inst_7 : Algebra E L] [IsScalarTower K E L] [Finite G]... | If `G` is a finite Galois group for `L/K`, `H` is a Galois group for `L/E`, and `E/K` is
Galois, then `H` is a normal subgroup of `G`. | true |
trans_trichotomous_left | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {r : α → α → Prop} [IsTrans α r] [Std.Trichotomous r] {a b c : α}, ¬r b a → r b c → r a c | null | true |
MeasureTheory.Measure.AbsolutelyContinuous.map_of_aemeasurable | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ ν : MeasureTheory.Measure α},
μ.AbsolutelyContinuous ν →
∀ {f : α → β},
AEMeasurable f ν → (MeasureTheory.Measure.map f μ).AbsolutelyContinuous (MeasureTheory.Measure.map f ν) | null | true |
ProbabilityTheory.Kernel.iIndepSets_zero_right._simp_1 | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {π : ι → Set (Set Ω)}, ProbabilityTheory.Kernel.iIndepSets π κ 0 = True | null | false |
Lean.Meta.Sym.Arith.ClassifyResult.commRing.injEq | Lean.Meta.Sym.Arith.Types | ∀ (id id_1 : ℕ),
(Lean.Meta.Sym.Arith.ClassifyResult.commRing id = Lean.Meta.Sym.Arith.ClassifyResult.commRing id_1) = (id = id_1) | null | true |
cfc_mono._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
Set.MapsTo.inter_inter | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t₁ t₂ : Set β} {f : α → β},
Set.MapsTo f s₁ t₁ → Set.MapsTo f s₂ t₂ → Set.MapsTo f (s₁ ∩ s₂) (t₁ ∩ t₂) | null | true |
_private.Mathlib.GroupTheory.FreeGroup.Reduce.0.FreeAddGroup.toWord_add_mk_eq._proof_1_22 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (b : Bool) (x : FreeAddGroup α) (i : ℕ),
i + 1 ≤ (x.toWord ++ [(a, b)]).length → i < (x.toWord ++ [(a, b)]).length | null | false |
TopPair.Homotopy | Mathlib.Topology.Category.TopPair | {X Y : TopPair} → (X ⟶ Y) → (X ⟶ Y) → Type u | A homotopy of maps between topological pairs is a homotopy on the first space and a homotopy on
the second space that fit in a commutative square with the maps of the pairs. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.ErdosStoneSimonovits.0.SimpleGraph.ErdosStone.filter.pi.exists_le_card_fiber._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Extremal.ErdosStoneSimonovits | ∀ {α : Type u_1} {n : ℕ} {s : Finset α}, (Finset.powersetCard n s).Nonempty = (n ≤ s.card) | null | false |
Fin.succ_eq_last_succ | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {i : Fin n.succ}, i.succ = Fin.last (n + 1) ↔ i = Fin.last n | null | true |
R0Space.specializes_symmetric | Mathlib.Topology.Separation.Basic | ∀ {X : Type u} {inst : TopologicalSpace X} [self : R0Space X], Std.Symm Specializes | **Alias** of `R0Space.specializes_symm`.
---
In an R₀ space, the `Specializes` relation is symmetric. | true |
UpperHalfPlane.verticalStrip | Mathlib.Analysis.Complex.UpperHalfPlane.Topology | ℝ → ℝ → Set UpperHalfPlane | The vertical strip of width `A` and height `B`, defined by elements whose real part has absolute
value less than or equal to `A` and imaginary part is at least `B`. | true |
BoundedContinuousFunction._aux_Mathlib_Topology_ContinuousMap_BoundedCompactlySupported___unexpand_compactlySupported_1 | Mathlib.Topology.ContinuousMap.BoundedCompactlySupported | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.Limits.parallelPairHom._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} {X Y : C} [inst : CategoryTheory.Category.{u_1, u_2} C] {X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y')
(p : X ⟶ X') (q : Y ⟶ Y'),
CategoryTheory.CategoryStruct.comp g q = CategoryTheory.CategoryStruct.comp p g' →
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.parallelPair f g).... | null | false |
GenContFract.convs'Aux_stable_step_of_terminated | Mathlib.Algebra.ContinuedFractions.TerminatedStable | ∀ {K : Type u_1} {n : ℕ} [inst : DivisionRing K] {s : Stream'.Seq (GenContFract.Pair K)},
s.TerminatedAt n → GenContFract.convs'Aux s (n + 1) = GenContFract.convs'Aux s n | null | true |
Turing.TM0.Stmt.move.inj | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {a a_1 : Turing.Dir}, Turing.TM0.Stmt.move a = Turing.TM0.Stmt.move a_1 → a = a_1 | null | true |
CliffordAlgebra.GradedAlgebra.ι | Mathlib.LinearAlgebra.CliffordAlgebra.Grading | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(Q : QuadraticForm R M) → M →ₗ[R] DirectSum (ZMod 2) fun i => ↥(CliffordAlgebra.evenOdd Q i) | A version of `CliffordAlgebra.ι` that maps directly into the graded structure. This is
primarily an auxiliary construction used to provide `CliffordAlgebra.gradedAlgebra`. | true |
Cardinal.isInaccessible_def | Mathlib.SetTheory.Cardinal.Regular | ∀ {c : Cardinal.{u_1}}, c.IsInaccessible ↔ Cardinal.aleph0 < c ∧ c.IsRegular ∧ c.IsStrongLimit | null | true |
Char.ltAsymm | Init.Data.Char.Lemmas | Std.Asymm fun x1 x2 => x1 < x2 | null | true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.foldlM.eq_def | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : δ → (a : α) → β a → m δ)
(x : δ) (x_1 : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldlM f x x_1 =
match x, x_1 with
| d, Std.DHashMap.Internal.AssocList.nil => pure d
| d, Std.DHashMap.... | null | true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.goWithIncremental._proof_1 | Lean.Elab.Tactic.Induction | ∀ (__s : Array Lean.Elab.Tactic.ElimApp.Alt) (i : Fin __s.size), ↑i < __s.size | null | false |
IsNotUnital.isNotUnital | Mathlib.Algebra.Group.Monoid | ∀ {A : Type u_2} {inst : Mul A} [self : IsNotUnital A] (u : A), ∃ x, u * x ≠ x ∨ x * u ≠ x | null | true |
List.min?_cons' | Init.Data.List.MinMax | ∀ {α : Type u_1} {x : α} [inst : Min α] {xs : List α}, (x :: xs).min? = some (List.foldl min x xs) | null | true |
UniformSpace.Completion.instNormedSpace._proof_2 | Mathlib.Analysis.Normed.Module.Completion | ∀ (𝕜 : Type u_2) (E : Type u_1) [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
(r : 𝕜) (x : UniformSpace.Completion E), ‖r • x‖ ≤ ‖r‖ * ‖x‖ | null | false |
CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone._proof_2 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {α : Type u_1}
[inst_1 : CategoryTheory.Limits.HasFiniteCoproducts C]
[CategoryTheory.Limits.HasColimitsOfShape (Finset (CategoryTheory.Discrete α)) C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete α) C),
CategoryTheory.Limits.HasColimit (Cat... | null | false |
Stream'.WSeq.productive_dropn | Mathlib.Data.WSeq.Productive | ∀ {α : Type u} (s : Stream'.WSeq α) [s.Productive] (n : ℕ), (s.drop n).Productive | null | true |
Submodule.Quotient.instSMul' | Mathlib.LinearAlgebra.Quotient.Defs | {R : Type u_1} →
{M : Type u_2} →
[inst : Ring R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{S : Type u_3} →
[inst_3 : SMul S R] → [inst_4 : SMul S M] → [IsScalarTower S R M] → (P : Submodule R M) → SMul S (M ⧸ P) | null | true |
Std.ExtDHashMap.mem_alter | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : Option (β k) → Option (β k)},
k' ∈ m.alter k f ↔ if (k == k') = true then (f (m.get? k)).isSome = true else k' ∈ m | null | true |
RBTree.RBMap.find?.eq_1 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : RBTree.RBMap α β cmp) (k : α),
t.find? k = Option.map (fun x => x.2) (t.findEntry? k) | null | true |
IsCompact.exists_thickening_image_subset | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {β : Type u_2} [inst_1 : PseudoEMetricSpace β] {f : α → β} {K : Set α}
{U : Set β},
IsCompact K →
IsOpen U →
(∀ x ∈ K, ContinuousAt f x) → Set.MapsTo f K U → ∃ ε > 0, ∃ V ∈ nhdsSet K, Metric.thickening ε (f '' V) ⊆ U | null | true |
Lean.Lsp.instHashableRpcRef | Lean.Server.Rpc.Basic | Hashable Lean.Lsp.RpcRef | null | true |
CategoryTheory.sum.inrCompInverseAssociator_inv_app | Mathlib.CategoryTheory.Sums.Associator | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(E : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (X : D ⊕ E),
(CategoryTheory.sum.inrCompInverseAssociator C D E).inv.app X =
CategoryTheory.CategoryStruct.id
((((CategoryTheo... | null | true |
Std.DTreeMap.Internal.Const.RoiSliceData.rec | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Const.RoiSliceData α β → Sort u_1} →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => β) →
(range : Std.Roi α) → motive { treeMap := treeMap, range := range }) →
(t : Std.DTreeMap.Internal.Const.Roi... | null | false |
MvPolynomial.supported.eq_1 | Mathlib.Algebra.MvPolynomial.Supported | ∀ {σ : Type u_1} (R : Type u) [inst : CommSemiring R] (s : Set σ),
MvPolynomial.supported R s = Algebra.adjoin R (MvPolynomial.X '' s) | null | true |
MeasureTheory.SimpleFunc.instLattice._proof_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Lattice β] (a b : MeasureTheory.SimpleFunc α β),
SemilatticeInf.inf a b ≤ a | null | false |
Subsemigroup.le_comap_map | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (S : Subsemigroup M) {f : M →ₙ* N},
S ≤ Subsemigroup.comap f (Subsemigroup.map f S) | null | true |
ProbabilityTheory.Kernel.comap._proof_1 | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_3} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_1}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (g : γ → α), Measurable g → Measurable (⇑κ ∘ g) | null | false |
_private.Mathlib.Topology.DiscreteSubset.0.IsDiscrete.iUnion._simp_1_2 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {S : Set X}, (Sᶜ ∈ Filter.codiscrete X) = (IsClosed S ∧ IsDiscrete S) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.