name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddSubgroup.upperCentralSeries_one | Mathlib.GroupTheory.Nilpotent | ∀ (G : Type u_1) [inst : AddGroup G], AddSubgroup.upperCentralSeries G 1 = AddSubgroup.center G | null | true |
iff_def | Init.Core | ∀ {a b : Prop}, (a ↔ b) ↔ (a → b) ∧ (b → a) | null | true |
_private.Mathlib.Analysis.PSeries.0.sum_Ioo_inv_sq_le._simp_1_11 | Mathlib.Analysis.PSeries | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G), a⁻¹ = 1 / a | null | false |
CategoryTheory.Abelian.LeftResolution.ofCompIso | Mathlib.Algebra.Homology.LeftResolution.Transport | {A : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] →
{C' : Type u_4} →
[inst_2 : CategoryTheory.Category.{v_3, u_4} C'] →
{ι : CategoryTheory.Functor C A} →
CategoryTheory.Abelian.LeftR... | If we have an isomorphism `e : G ⋙ ι' ≅ ι`, then any `Λ : LeftResolution ι`
induces `Λ.ofCompIso e : LeftResolution ι'`. | true |
CategoryTheory.ProjectivePresentation.projective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (self : CategoryTheory.ProjectivePresentation X),
CategoryTheory.Projective self.p | null | true |
Setoid.quotientQuotientEquivQuotient._proof_4 | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} (r s : Setoid α) (h : r ≤ s) (x y : Quot ⇑r),
(Setoid.ker (Quot.mapRight h)) x y → Quotient.liftOn' x Quotient.mk'' ⋯ = Quotient.liftOn' y Quotient.mk'' ⋯ | null | false |
PMF.bind_pure_comp | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (p : PMF α), p.bind (PMF.pure ∘ f) = PMF.map f p | null | true |
_private.Mathlib.Tactic.NormNum.Inv.0.Mathlib.Meta.NormNum.Result.inv._proof_2 | Mathlib.Tactic.NormNum.Inv | ∀ {u : Lean.Level} {α : Q(Type u)} (dsα : Q(DivisionSemiring «$α»)) (dα : Q(DivisionRing «$α»))
(__defeqres : PLift («$dsα» =Q DivisionRing.toDivisionSemiring)), «$dsα» =Q DivisionRing.toDivisionSemiring | null | false |
Lean.Syntax.SepArray.ofElemsUsingRef | Init.Meta.Defs | {m : Type → Type} → [Monad m] → [Lean.MonadRef m] → {sep : String} → Array Lean.Syntax → m (Lean.Syntax.SepArray sep) | Constructs a typed separated array from elements by adding suitable separators.
The provided array should not include the separators.
The generated separators' source location is that of the syntax returned by `getRef`.
| true |
String.Pos.Raw.extract.go₁.match_1 | Init.Data.String.Basic | (motive : List Char → String.Pos.Raw → String.Pos.Raw → String.Pos.Raw → Sort u_1) →
(x : List Char) →
(x_1 x_2 x_3 : String.Pos.Raw) →
((x x_4 x_5 : String.Pos.Raw) → motive [] x x_4 x_5) →
((s : List Char) →
(c : Char) →
(cs : List Char) →
(h : s = c :: cs... | null | false |
CategoryTheory.StructuredArrow.createsLimitsOfShape | Mathlib.CategoryTheory.Limits.Comma | {J : Type w} →
[inst : CategoryTheory.Category.{w', w} J] →
{A : Type u₁} →
[inst_1 : CategoryTheory.Category.{v₁, u₁} A] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{X : T} →
{G : CategoryTheory.Functor A T} →
[CategoryTheory... | null | true |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.Basis.injective._simp_1_3 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α}, (f x ≠ x) = (x ∈ f.support) | null | false |
Equiv.Perm.mem_support_cycleOf_iff' | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_1} {f : Equiv.Perm α} {x y : α},
f x ≠ x → ∀ [inst : DecidableEq α] [inst_1 : Fintype α], y ∈ (f.cycleOf x).support ↔ f.SameCycle x y | null | true |
Fin.addNat?_eq_dif | Init.Data.Fin.OverflowAware | ∀ {n m : ℕ} {i : Fin n}, i.addNat? m = if h : ↑i + m < n then some ⟨↑i + m, h⟩ else none | null | true |
Module.Basis.ofIsCoprimeDifferentIdeal._proof_4 | Mathlib.RingTheory.DedekindDomain.LinearDisjoint | ∀ (A : Type u_5) (B : Type u_1) {K : Type u_7} {L : Type u_6} [inst : CommRing A] [inst_1 : Field K]
[inst_2 : Algebra A K] [IsFractionRing A K] [inst_4 : CommRing B] [inst_5 : Field L] [inst_6 : Algebra B L]
[inst_7 : Algebra A L] [inst_8 : Algebra K L] [FiniteDimensional K L] [inst_10 : IsScalarTower A K L] (R₁ :... | null | false |
SimpleGraph.Walk.lastDart_eq | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w} (h₁ : ¬p.Nil) (h₂ : 0 < p.darts.length),
p.lastDart h₁ = p.darts[p.darts.length - 1] | null | true |
_private.Mathlib.Algebra.BigOperators.Fin.0.Fin.prod_Ioo_castAdd._simp_1_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n),
Finset.Ioo (Fin.castAdd m i) (Fin.castAdd m j) = Finset.map (Fin.castAddEmb m) (Finset.Ioo i j) | null | false |
IsFreeGroup.lift_symm_apply | Mathlib.GroupTheory.FreeGroup.IsFreeGroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : IsFreeGroup G] {H : Type u_2} [inst_2 : Group H] (f : G →* H)
(a : IsFreeGroup.Generators G), IsFreeGroup.lift.symm f a = f (IsFreeGroup.of a) | null | true |
not_and_self._simp_1 | Init.SimpLemmas | ∀ {a : Prop}, (¬a ∧ a) = False | null | false |
Std.Time.PlainDate.toTimestamp | Std.Time.Zoned | Std.Time.PlainDate → Std.Time.TimeZone.ZoneRules → Std.Time.Timestamp | Converts a `PlainDate` to a `Timestamp` using the `ZoneRules`.
| true |
Int64.xor_self | Init.Data.SInt.Bitwise | ∀ {a : Int64}, a ^^^ a = 0 | null | true |
Lean.ConstantInfo.isDefinition | Lean.Declaration | Lean.ConstantInfo → Bool | null | true |
mem_contMDiffFiberwiseLinear_iff | Mathlib.Geometry.Manifold.VectorBundle.FiberwiseLinear | ∀ {𝕜 : Type u_1} (B : Type u_2) (F : Type u_3) [inst : TopologicalSpace B] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 F] {EB : Type u_4} [inst_4 : NormedAddCommGroup EB]
[inst_5 : NormedSpace 𝕜 EB] {HB : Type u_5} [inst_6 : TopologicalSpace HB] [inst_7 : Charted... | null | true |
CategoryTheory.Functor.equivCatHom._proof_2 | Mathlib.CategoryTheory.Category.Cat | ∀ (C D : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Category.{u_2, u_1} D]
(x : ↧C ⟶ ↧D), x.toFunctor.toCatHom = x.toFunctor.toCatHom | null | false |
MeasureTheory.IsAddFundamentalDomain.measure_zero_of_invariant | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α] [MeasureTheory.VAddInvariantMeasure G α μ] [Countable G],
MeasureTheory.IsAddFundamentalDomain G s μ → ∀ (t : Set α), (∀ (g : G), g +ᵥ t = t) ... | null | true |
List.findSome?_isSome_iff | Init.Data.List.Find | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {l : List α},
(List.findSome? f l).isSome = true ↔ ∃ x ∈ l, (f x).isSome = true | null | true |
_private.Mathlib.Algebra.Pointwise.Stabilizer.0.MulAction.mem_stabilizer_finset._simp_1_2 | Mathlib.Algebra.Pointwise.Stabilizer | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] {a : G} {s : Set α},
(a ∈ MulAction.stabilizer G s) = ∀ (b : α), a • b ∈ s ↔ b ∈ s | null | false |
TensorProduct.AlgebraTensorModule.uncurry._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ (R : Type u_5) (A : Type u_1) (B : Type u_2) (N : Type u_4) (P : Type u_3) [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : AddCommMonoid N]
[inst_6 : Module R N] [inst_7 : AddCommMonoid P] [inst_8 : Module R P] [inst_9 : Module A P]
[in... | null | false |
Sigma.mk.hcongr_4 | Mathlib.Data.Set.Sigma | ∀ (α α' : Type u),
α = α' →
∀ (β : α → Type v) (β' : α' → Type v),
β ≍ β' →
∀ (fst : α) (fst' : α'), fst ≍ fst' → ∀ (snd : β fst) (snd' : β' fst'), snd ≍ snd' → ⟨fst, snd⟩ ≍ ⟨fst', snd'⟩ | null | true |
Sum.comp_traverse | Mathlib.Control.Traversable.Instances | ∀ {σ : Type u} {F G : Type u → Type u} [inst : Applicative F] [inst_1 : Applicative G] [LawfulApplicative G]
{α β γ : Type u} (f : β → F γ) (g : α → G β) (x : σ ⊕ α),
Sum.traverse (Functor.Comp.mk ∘ (fun x => f <$> x) ∘ g) x = Functor.Comp.mk (Sum.traverse f <$> Sum.traverse g x) | null | true |
DividedPowers.mk.noConfusion | Mathlib.RingTheory.DividedPowers.Basic | {A : Type u_1} →
{inst : CommSemiring A} →
{I : Ideal A} →
{P : Sort u} →
{dpow : ℕ → A → A} →
{dpow_null : ∀ {n : ℕ} {x : A}, x ∉ I → dpow n x = 0} →
{dpow_zero : ∀ {x : A}, x ∈ I → dpow 0 x = 1} →
{dpow_one : ∀ {x : A}, x ∈ I → dpow 1 x = x} →
{d... | null | false |
_private.Mathlib.Tactic.MkIffOfInductiveProp.0.Mathlib.Tactic.MkIff.splitThenConstructor.match_1 | Mathlib.Tactic.MkIffOfInductiveProp | (motive : List Lean.MVarId → Sort u_1) →
(subgoals' : List Lean.MVarId) → (Unit → motive []) → ((x : List Lean.MVarId) → motive x) → motive subgoals' | null | false |
Lean.Parser.getNext | Lean.Parser.Types | String → String.Pos.Raw → Char | Return character after position `pos` | true |
Lean.Elab.Term.LetIdDeclView.mk.inj | Lean.Elab.Binders | ∀ {id : Lean.Syntax} {binders : Array Lean.Syntax} {type value id_1 : Lean.Syntax} {binders_1 : Array Lean.Syntax}
{type_1 value_1 : Lean.Syntax},
{ id := id, binders := binders, type := type, value := value } =
{ id := id_1, binders := binders_1, type := type_1, value := value_1 } →
id = id_1 ∧ binders =... | null | true |
Int.fmod_sub_cancel_left | Init.Data.Int.DivMod.Lemmas | ∀ {m n k : ℤ} (i : ℤ), (i - m).fmod n = (i - k).fmod n ↔ m.fmod n = k.fmod n | null | true |
Lean.Elab.Term.FunBinders.State.recOn | Lean.Elab.Binders | {motive : Lean.Elab.Term.FunBinders.State → Sort u} →
(t : Lean.Elab.Term.FunBinders.State) →
((fvars : Array Lean.Expr) →
(lctx : Lean.LocalContext) →
(localInsts : Lean.LocalInstances) →
(expectedType? : Option Lean.Expr) →
motive { fvars := fvars, lctx := lctx, local... | null | false |
_private.Lean.Meta.Tactic.UnifyEq.0.Lean.Meta.unifyEq?.match_1 | Lean.Meta.Tactic.UnifyEq | (motive : Option (Lean.Meta.FVarSubst × Lean.MVarId) → Sort u_1) →
(__do_lift : Option (Lean.Meta.FVarSubst × Lean.MVarId)) →
((subst : Lean.Meta.FVarSubst) → (mvarId : Lean.MVarId) → motive (some (subst, mvarId))) →
((x : Option (Lean.Meta.FVarSubst × Lean.MVarId)) → motive x) → motive __do_lift | null | false |
CategoryTheory.GlueData'.V | Mathlib.CategoryTheory.GlueData | {C : Type u₁} →
[inst : CategoryTheory.Category.{v, u₁} C] → (self : CategoryTheory.GlueData' C) → (i j : self.J) → i ≠ j → C | Objects representing the intersections. | true |
AddSubgroup.disjoint_def | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] {H₁ H₂ : AddSubgroup G}, Disjoint H₁ H₂ ↔ ∀ {x : G}, x ∈ H₁ → x ∈ H₂ → x = 0 | null | true |
gcd_one_left | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α), gcd 1 a = 1 | null | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.activateTheoremsCore._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Internalize | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Fin.finsetImage_castSucc_Ioi | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (i : Fin n), Finset.image Fin.castSucc (Finset.Ioi i) = Finset.Ioo i.castSucc (Fin.last n) | null | true |
SModEq.instIsEquiv | 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},
IsEquiv M (SModEq U) | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.KInjective.0.CochainComplex.isKInjective_of_injective_aux._proof_1_2 | Mathlib.Algebra.Homology.HomotopyCategory.KInjective | ∀ (n : ℤ), n + 2 + -1 = n + 1 | null | false |
SignType.one_le_iff._simp_1 | Mathlib.Basic.Sign.Defs | ∀ {a : SignType}, (1 ≤ a) = (a = 1) | null | false |
Mathlib.Linter.TextBased.UnicodeLinter.Char.printCodepointHex | Mathlib.Tactic.Linter.TextBased.UnicodeLinter | Char → String | Prints a unicode character's codepoint in hexadecimal with prefix 'U+'.
E.g., 'a' is "U+0061". | true |
Filter.Tendsto.zero_vadd_const | Mathlib.Topology.Algebra.MulAction | ∀ {M : Type u_1} {X : Type u_2} {α : Type u_4} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X]
[inst_2 : AddMonoid M] [inst_3 : AddAction M X] [ContinuousVAdd M X] {f : α → M} {l : Filter α},
Filter.Tendsto f l (nhds 0) → ∀ (a : X), Filter.Tendsto (fun x => f x +ᵥ a) l (nhds a) | null | true |
Ideal.Fiber.algEquivQuotient._proof_12 | Mathlib.RingTheory.LocalRing.ResidueField.Fiber | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime]
(x y :
TensorProduct R S (Localization.AtPrime p) ⧸
Ideal.map Algebra.TensorProduct.includeRight (IsLocalRing.maximalIdeal (Localization.AtPrime p))),
((Ideal.map Algebra.T... | null | false |
Lean.Macro.Context | Init.Prelude | Type | The read-only context for the `MacroM` monad. | true |
EReal.coe_lt_coe | Mathlib.Data.EReal.Basic | ∀ {x y : ℝ}, x < y → ↑x < ↑y | **Alias** of the reverse direction of `EReal.coe_lt_coe_iff`. | true |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.iterate_derivative_prod_X_sub_C._proof_1_13 | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u_1} {S : Finset R} (k : ℕ) (p : Finset R × R),
p ∈
{x ∈ Finset.powersetCard (S.card - (k + 1)) S ×ˢ S |
match x with
| (T, i) => i ∉ T} ↔
p.1 ∈ Finset.powersetCard (S.card - (k + 1)) S ∧ p.2 ∈ S \ p.1 | null | false |
ModuleCon.ker._proof_1 | Mathlib.Algebra.Module.Congruence.Defs | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_1} {N : Type u_2} [inst : Monoid R] [inst_1 : Monoid S]
[inst_2 : AddMonoid M] [inst_3 : AddMonoid N] [inst_4 : DistribMulAction R M] [inst_5 : DistribMulAction S N]
{φ : R →* S}, AddHomClass (M →ₑ+[φ] N) M N | null | false |
Lean.Compiler.LCNF.SpecParamInfo.other.sizeOf_spec | Lean.Compiler.LCNF.SpecInfo | sizeOf Lean.Compiler.LCNF.SpecParamInfo.other = 1 | null | true |
MvPolynomial.decidableRestrictDegree | Mathlib.FieldTheory.Finite.Polynomial | (σ : Type u) → (m : ℕ) → DecidablePred fun x => x ∈ {n | ∀ (i : σ), n i ≤ m} | null | true |
Matrix.IsPivotedBy.casesOn | Mathlib.LinearAlgebra.Matrix.Echelon.Pivot | {m : Type u_1} →
{n : Type u_2} →
{R : Type u_3} →
[inst : Zero R] →
[inst_1 : LT m] →
[inst_2 : LT n] →
{A : Matrix m n R} →
{l : m → WithTop n} →
{motive : A.IsPivotedBy l → Sort u} →
(t : A.IsPivotedBy l) →
... | null | false |
TensorAlgebra.Rel.recOn | Mathlib.LinearAlgebra.TensorAlgebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{motive : (a a_1 : FreeAlgebra R M) → TensorAlgebra.Rel R M a a_1 → Prop} {a a_1 : FreeAlgebra R M}
(t : TensorAlgebra.Rel R M a a_1),
(∀ {a b : M}, motive (FreeAlgebra.ι R (a + b)) (FreeAlgebra.ι R a + FreeAl... | null | false |
Turing.PartrecToTM2.Λ'.copy.noConfusion | Mathlib.Computability.TuringMachine.ToPartrec | {P : Sort u} → {q q' : Turing.PartrecToTM2.Λ'} → q.copy = q'.copy → (q = q' → P) → P | null | false |
CategoryTheory.Limits.isoZeroBiprod._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y],
CategoryTheory.Limits.IsZero X →
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.snd CategoryTheory.Limits.biprod.... | null | false |
Tactic.ComputeAsymptotics.WellFormedBasis.eq_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ (basis : Tactic.ComputeAsymptotics.Basis),
Tactic.ComputeAsymptotics.WellFormedBasis basis =
(List.Pairwise (fun x y => (Real.log ∘ y) =o[Filter.atTop] (Real.log ∘ x)) basis ∧
∀ f ∈ basis, Filter.Tendsto f Filter.atTop Filter.atTop) | null | true |
MeasureTheory.VectorMeasure.withDensity.eq_1 | Mathlib.MeasureTheory.VectorMeasure.WithDensityVec | ∀ {X : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G]
[inst_5 : NormedSpace ℝ G] (μ : MeasureTheory.VectorMeasure X F) (f : X → E) (B :... | null | true |
RootPairing.GeckConstruction.equivLieAlgebra._proof_10 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basis | ∀ {K : Type u_1} [inst : Field K] [inst_1 : CharZero K] [inst_2 : IsAlgClosed K] {L : Type u_2} [inst_3 : LieRing L]
[inst_4 : LieAlgebra K L] [inst_5 : FiniteDimensional K L] [inst_6 : LieAlgebra.IsSimple K L] (H : LieSubalgebra K L)
[inst_7 : H.IsCartanSubalgebra] (b : (LieAlgebra.IsKilling.rootSystem H).Base),
... | null | false |
CategoryTheory.Idempotents.KaroubiHomologicalComplexEquivalence.unitIso._proof_2 | Mathlib.CategoryTheory.Idempotents.HomologicalComplex | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_1}
{c : ComplexShape ι} (P : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C c)),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.id (CategoryTheory.Idempotents.Karoubi (Homo... | null | false |
instOrderTopSubtypeIsIdempotentElem._proof_1 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {M : Type u_1} [inst : CommMonoid M], IsIdempotentElem 1 | null | false |
exists₅_congr | Init.PropLemmas | ∀ {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {δ : (a : α) → (b : β a) → γ a b → Sort u_4}
{ε : (a : α) → (b : β a) → (c : γ a b) → δ a b c → Sort u_5}
{p q : (a : α) → (b : β a) → (c : γ a b) → (d : δ a b c) → ε a b c d → Prop},
(∀ (a : α) (b : β a) (c : γ a b) (d : δ a b c) (e : ε a b c d),... | null | true |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse._proof_3 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
[inst_3 : CategoryTheory.BraidedCategory D] {X Y Z : CategoryTheory.Functor C (CategoryTheory.CommMon D)} (f : X ⟶ Y)
(g : Y ⟶ Z),
CategoryTh... | null | false |
CategoryTheory.Functor.weightedLimFlipObjIso | Mathlib.CategoryTheory.Limits.Weighted.HasWeightedLimit | {J : Type u} →
[inst : CategoryTheory.Category.{v, u} J] →
{C : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} C] →
(F : CategoryTheory.Functor J C) →
[inst_2 : F.HasWeightedLimFlipObj] →
F.hasWeightedLimit.ι.inv.op.comp F.weightedLimFlipObj' ≅ F.weightedLimFlipObj | When `HasWeightedLimFlipObj.{w} F` holds, the composition
of the inverse of the equivalence `F.hasWeightedLimit.ι.op` with
`weightedLimFlipObj'.{w} F` identifies to `weightedLimFlipObj.{w} F`. | true |
FirstOrder.Language.BoundedFormula.realize_relabelEquiv._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {β : Type v'} {g : α ≃ β} {k : ℕ}
{φ : L.BoundedFormula α k} {v : β → M} {xs : Fin k → M},
((FirstOrder.Language.BoundedFormula.relabelEquiv g) φ).Realize v xs = φ.Realize (v ∘ ⇑g) xs | null | false |
Lean.LLVM.countBasicBlocks | Lean.Compiler.IR.LLVMBindings | {ctx : Lean.LLVM.Context} → Lean.LLVM.Value ctx → BaseIO UInt64 | null | true |
BoundedContinuousFunction.toContinuousMapStarₐ._proof_6 | Mathlib.Topology.ContinuousMap.Bounded.Star | ∀ {β : Type u_1} [inst : NormedRing β], BoundedAdd β | null | false |
CompactlySupportedContinuousMap.finsetInf'_apply | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : SemilatticeInf β] [inst_2 : Zero β]
[inst_3 : TopologicalSpace β] [inst_4 : ContinuousInf β] {ι : Type u_5} {s : Finset ι} (H : s.Nonempty)
(f : ι → CompactlySupportedContinuousMap α β) (a : α), (s.inf' H f) a = s.inf' H fun i => (f i) a | null | true |
_private.Mathlib.CategoryTheory.Sites.Sieves.Presieve.0.CategoryTheory.Presieve.instHasPullbacksSingletonOfHasPullback.match_1 | Mathlib.CategoryTheory.Sites.Sieves.Presieve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Z : C} (g : Z ⟶ X)
(motive : (Z_1 : C) → (h : Z_1 ⟶ X) → CategoryTheory.Presieve.singleton g h → Prop) (Z_1 : C) (h : Z_1 ⟶ X)
(h_1 : CategoryTheory.Presieve.singleton g h), (∀ (_ : Unit), motive Z g ⋯) → motive Z_1 h h_1 | null | false |
instInhabitedCtopSet._proof_2 | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} (_s _t : Set α), ∀ _a ∈ id _s ∩ id _t, id (_s ∩ _t) ⊆ id (_s ∩ _t) | null | false |
CategoryTheory.Lax.StrongTrans.vComp._proof_1 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C]
{F G H : CategoryTheory.LaxFunctor B C} (η : CategoryTheory.Lax.StrongTrans F G)
(θ : CategoryTheory.Lax.StrongTrans G H) {a b : B} (f : a ⟶ b),
(CategoryTheory.Bicategory.associator (η.toLax.app a) (θ.toLa... | null | false |
_private.Lean.Compiler.LCNF.Bind.0.Lean.Compiler.LCNF.CompilerM.codeBind.go._unsafe_rec | Lean.Compiler.LCNF.Bind | {pu : Lean.Compiler.LCNF.Purity} →
(Lean.FVarId → Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.Code pu)) →
Lean.Compiler.LCNF.Code pu → ReaderT Lean.FVarIdSet Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.Code pu) | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.isEmpty_filterMap_eq_true._simp_1_3 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {x : Option α} {α_1 : Type u_2} {f : α → α_1}, (Option.map f x = none) = (x = none) | null | false |
Relation.bicompl_map_eq_of_injective | Mathlib.Logic.Relation | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (r : α → β → Prop) {f : α → γ} {g : β → δ},
Function.Injective f → Function.Injective g → Function.bicompl (Relation.Map r f g) f g = r | null | true |
AddGroupTopology.instInfSet.eq_1 | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u} [inst : AddGroup α],
AddGroupTopology.instInfSet =
{
sInf := fun S =>
{ toTopologicalSpace := sInf (AddGroupTopology.toTopologicalSpace '' S), toIsTopologicalAddGroup := ⋯ } } | null | true |
Std.DTreeMap.getEntryGE._proof_1 | Std.Data.DTreeMap.AdditionalOperations | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} [Std.TransCmp cmp] (t : Std.DTreeMap α β cmp),
t.inner.Ordered | null | false |
Std.TreeMap.Raw.ordCompare_maxKey!_modify_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} [inst : Ord α] [Std.TransOrd α] {t : Std.TreeMap.Raw α β compare} [inst_2 : Inhabited α],
t.WF → ∀ {k : α} {f : β → β}, compare (t.modify k f).maxKey! t.maxKey! = Ordering.eq | null | true |
_private.Mathlib.Basic.IsEmpty.Basic.0.isEmpty_sum._simp_1_3 | Mathlib.Basic.IsEmpty.Basic | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.ediv.match_1.eq_1 | Init.Data.Int.DivMod.Bootstrap | ∀ (motive : ℤ → ℤ → Sort u_1) (m n : ℕ) (h_1 : (m n : ℕ) → motive (Int.ofNat m) (Int.ofNat n))
(h_2 : (m n : ℕ) → motive (Int.ofNat m) (Int.negSucc n)) (h_3 : (a : ℕ) → motive (Int.negSucc a) 0)
(h_4 : (m n : ℕ) → motive (Int.negSucc m) (Int.ofNat n.succ))
(h_5 : (m n : ℕ) → motive (Int.negSucc m) (Int.negSucc n)... | null | true |
StarSubalgebra.commCStarAlgebra._proof_6 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {S : Type u_2} {A : Type u_1} [inst : CommCStarAlgebra A] [inst_1 : SetLike S A] [inst_2 : SubringClass S A]
[inst_3 : SMulMemClass S ℂ A] [inst_4 : StarMemClass S A] (s : S) [h_closed : IsClosed ↑s] (a b c : ↥s),
(a + b) * c = a * c + b * c | null | false |
ModuleCat.isLimitKernelFork._proof_5 | Mathlib.Algebra.Category.ModuleCat.Kernels | ∀ {R : Type u_2} [inst : Ring R] {M N P : ModuleCat R} (f : M ⟶ N) (g : N ⟶ P),
Function.Exact ⇑(ModuleCat.Hom.hom f) ⇑(ModuleCat.Hom.hom g) → (ModuleCat.Hom.hom f).range = (ModuleCat.Hom.hom g).ker | null | false |
MonoidHom.subgroupComap_surjective_of_surjective | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] (f : G →* G') (H' : Subgroup G'),
Function.Surjective ⇑f → Function.Surjective ⇑(f.subgroupComap H') | **Alias** of `MonoidHom.subgroupComap_surjective`. | true |
AddMonoidAlgebra.zero.eq_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : Zero M],
AddMonoidAlgebra.zero = { one := AddMonoidAlgebra.single 0 1 } | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toFin_signExtend._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ}, ¬1 < 2 → False | null | false |
Std.DHashMap.contains_of_isEmpty | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{a : α}, m.isEmpty = true → m.contains a = false | null | true |
EuclideanGeometry.left_ne_of_oangle_eq_neg_pi_div_two | 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}, EuclideanGeometry.oangle p₁ p₂ p₃ = ↑(-Real.pi / 2) → p₁ ≠ p₂ | If the angle between three points is `-π / 2`, the first two points are not equal. | true |
Sublocale.carrier.instCompleteLattice._proof_8 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] {S : Sublocale X} (s : Set ↥S), IsLUB s (sSup s) | null | false |
Coe.noConfusionType | Init.Coe | Sort u_1 → {α : Sort u} → {β : Sort v} → Coe α β → {α' : Sort u} → {β' : Sort v} → Coe α' β' → Sort u_1 | null | false |
InfHom.withTop_toFun | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] (f : InfHom α β) (a : WithTop α),
f.withTop a = WithTop.map (⇑f) a | null | true |
CategoryTheory.CoreSmallCategoryOfSet.arrowEquiv | Mathlib.CategoryTheory.SmallRepresentatives | {Ω : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(h : CategoryTheory.CoreSmallCategoryOfSet Ω C) →
CategoryTheory.Arrow ↑h.smallCategoryOfSet.obj ≃ CategoryTheory.Arrow C | Given `h : CoreSmallCategoryOfSet Ω C`, the equivalence of categories
`h.smallCategoryOfSet.obj ≌ C` is actually an isomorphism: it induces
a bijection on the type of arrows. | true |
CategoryTheory.SmallObject.SuccStruct.Iteration.noConfusionType | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
{Φ : CategoryTheory.SmallObject.SuccStruct C} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : CategoryTheory.Limits.HasIter... | null | false |
Algebra.intTraceAux._proof_5 | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : Algebra A B] [inst_3 : Field K] [inst_4 : Field L] [inst_5 : Algebra A K] [inst_6 : Algebra K L]
[inst_7 : Algebra A L] [IsScalarTower A K L] [inst_9 : Algebra B L] [inst_10 : IsScalarTower A B L]
[Is... | null | false |
Set.mem_union._simp_1 | Mathlib.Data.Set.Basic | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) | null | false |
UInt8.neg_one_and | Init.Data.UInt.Bitwise | ∀ {a : UInt8}, -1 &&& a = a | null | true |
TopModuleCat.induced._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] {M : ModuleCat R} {I : Type u_3} {X : I → TopModuleCat R}
(f : (i : I) → M ⟶ (X i).toModuleCat), ContinuousAdd ↑M | null | false |
MeasureTheory.Measure.isComplete_iff | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
μ.IsComplete ↔ ∀ (s : Set α), μ s = 0 → MeasurableSet s | null | true |
Turing.ToPartrec.Code.casesOn | Mathlib.Computability.TuringMachine.Config | {motive : Turing.ToPartrec.Code → Sort u} →
(t : Turing.ToPartrec.Code) →
motive Turing.ToPartrec.Code.zero' →
motive Turing.ToPartrec.Code.succ →
motive Turing.ToPartrec.Code.tail →
((a a_1 : Turing.ToPartrec.Code) → motive (a.cons a_1)) →
((a a_1 : Turing.ToPartrec.Code) → mo... | null | false |
Quaternion.finrank_eq_four | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] [StrongRankCondition R], Module.finrank R (Quaternion R) = 4 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.