name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.forall₂_reverse_iff | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β},
List.Forall₂ R l₁.reverse l₂.reverse ↔ List.Forall₂ R l₁ l₂ | null | true |
Lean.Elab.Tactic.TacticParsedSnapshot.below | Lean.Elab.Term.TermElabM | {motive_1 : Lean.Elab.Tactic.TacticParsedSnapshot → Sort u} →
{motive_2 :
Lean.Language.TransformedSnap (Lean.Elab.Tactic.TacticParsedSnapshotInner Lean.Elab.Tactic.TacticParsedSnapshot) →
Sort u} →
{motive_3 : Array (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot) → Sort u} →
... | null | false |
ENat.iSup_add_iSup_of_monotone | Mathlib.Data.ENat.Lattice | ∀ {ι : Type u_4} [inst : Preorder ι] [IsDirectedOrder ι] {f g : ι → ℕ∞},
Monotone f → Monotone g → iSup f + iSup g = ⨆ a, f a + g a | null | true |
Aesop.Frontend.Parser.«feature(_)» | Aesop.Frontend.RuleExpr | Lean.ParserDescr | null | true |
_private.Mathlib.Analysis.Complex.Conformal.0.isConformalMap_complex_linear._simp_1_4 | Mathlib.Analysis.Complex.Conformal | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Std.ExtTreeSet.get!_min! | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α],
t ≠ ∅ → t.get! t.min! = t.min! | null | true |
Subgroup.subgroupOf_inj._simp_2 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {H₁ H₂ K : Subgroup G}, (H₁.subgroupOf K = H₂.subgroupOf K) = (H₁ ⊓ K = H₂ ⊓ K) | null | false |
LinearIsometry.coe_toSpanSingleton | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : SeminormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] {v : E} (hv : ‖v‖ = 1),
(LinearIsometry.toSpanSingleton 𝕜 E hv).toLinearMap = LinearMap.toSpanSingleton 𝕜 E v | null | true |
HasDerivWithinAt.mono | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s t : Set 𝕜},
HasDerivWithinAt f f' t x → s ⊆ t → HasDerivWithinAt f f' s x | null | true |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.instNoMinOrderElemIoc.match_1 | Mathlib.Order.Interval.Set.Basic | ∀ (α : Type u_1) [inst : Preorder α] {x y : α} (motive : ↑(Set.Ioc x y) → Prop) (x_1 : ↑(Set.Ioc x y)),
(∀ (a : α) (ha : a ∈ Set.Ioc x y), motive ⟨a, ha⟩) → motive x_1 | null | false |
List.Perm.pairwise_iff | Init.Data.List.Perm | ∀ {α : Type u_1} {R : α → α → Prop},
(∀ {x y : α}, R x y → R y x) → ∀ {l₁ l₂ : List α}, l₁.Perm l₂ → (List.Pairwise R l₁ ↔ List.Pairwise R l₂) | null | true |
Set.Ioo.pos | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Zero R] [inst_1 : One R] [inst_2 : Preorder R] (x : ↑(Set.Ioo 0 1)), 0 < ↑x | null | true |
IsFractionRing.algHom_commutes | Mathlib.RingTheory.Localization.FractionRing | ∀ {A : Type u_4} [inst : CommRing A] {B : Type u_6} [inst_1 : CommRing B] [inst_2 : Algebra A B] {K₁ : Type u_8}
{K₂ : Type u_9} [inst_3 : Field K₁] [inst_4 : Field K₂] [inst_5 : Algebra A K₁] [inst_6 : Algebra A K₂]
[IsFractionRing A K₁] {L₁ : Type u_10} {L₂ : Type u_11} [inst_8 : Field L₁] [inst_9 : Field L₂]
[... | null | true |
OrderIso.smulRight_symm_apply | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : GroupWithZero α] [inst_1 : Preorder α] [inst_2 : Preorder β]
[inst_3 : MulAction α β] [inst_4 : PosSMulMono α β] [inst_5 : PosSMulReflectLE α β] {a : α} (ha : 0 < a) (b : β),
(RelIso.symm (OrderIso.smulRight ha)) b = a⁻¹ • b | null | true |
MultilinearMap.freeFinsuppEquiv._proof_7 | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {ι' : Type u_1} {R : Type u_2} [inst : CommSemiring R], LinearMap.CompatibleSMul (Π₀ (x : ι'), R) (ι' →₀ R) R R | null | false |
Lean.Elab.Term.mkNoImplicitLambdaAnnotation | Lean.Elab.Term.TermElabM | Lean.Expr → Lean.Expr | null | true |
MeasureTheory.piContent_eq_measure_pi | Mathlib.Probability.ProductMeasure | ∀ {ι : Type u_1} {X : ι → Type u_2} {mX : (i : ι) → MeasurableSpace (X i)} (μ : (i : ι) → MeasureTheory.Measure (X i))
[hμ : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)] [inst : Fintype ι] {s : Set ((i : ι) → X i)},
MeasurableSet s → (MeasureTheory.piContent μ) s = (MeasureTheory.Measure.pi μ) s | null | true |
Matrix.transpose_eq_natCast | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : AddMonoidWithOne α] {M : Matrix n n α} {d : ℕ},
M.transpose = ↑d ↔ M = ↑d | null | true |
Lean.Elab.Do.ContInfo.toContInfoRef | Lean.Elab.Do.Basic | Lean.Elab.Do.ContInfo → Lean.Elab.Do.ContInfoRef | null | true |
Batteries.UnionFind.recOn | Batteries.Data.UnionFind.Basic | {motive : Batteries.UnionFind → Sort u} →
(t : Batteries.UnionFind) →
((arr : Array Batteries.UFNode) →
(parentD_lt : ∀ {i : ℕ}, i < arr.size → Batteries.UnionFind.parentD arr i < arr.size) →
(rankD_lt :
∀ {i : ℕ},
Batteries.UnionFind.parentD arr i ≠ i →
... | null | false |
derivationOfSectionOfKerSqZero_apply_coe | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra R S] (f : P →ₐ[R] S) (hf' : RingHom.ker f ^ 2 = ⊥) (g : S →ₐ[R] P)
(hg : f.comp g = AlgHom.id R S) (x : P), ↑((derivationOfSectionOfKerSqZero f hf' g hg) x) = x - g... | null | true |
Finset.coe_zero | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : Zero α], ↑0 = 0 | null | true |
«term_≃⋆+*_» | Mathlib.Algebra.Star.StarRingHom | Lean.TrailingParserDescr | A *⋆-ring* equivalence is an equivalence preserving addition, multiplication, and the star
operation, which allows for considering both unital and non-unital equivalences with a single
structure. | true |
_private.Mathlib.RingTheory.Smooth.IntegralClosure.0.exists_derivative_mul_eq_and_isIntegral_coeff._simp_1_8 | Mathlib.RingTheory.Smooth.IntegralClosure | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) | null | false |
CategoryTheory.CosimplicialObject.augmentOfIsInitial_right | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {T : C}
(hT : CategoryTheory.Limits.IsInitial T), (X.augmentOfIsInitial hT).right = X | null | true |
_private.Mathlib.Analysis.CStarAlgebra.Unitary.Connected.0.expUnitary_argSelfAdjoint._simp_1_1 | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | NormedSpace.exp = Complex.exp | null | false |
Lean.Parser.instCoeParserParserAliasValue | Lean.Parser.Extension | Coe Lean.Parser.Parser Lean.Parser.ParserAliasValue | null | true |
OpenPartialHomeomorph.trans._proof_2 | Mathlib.Topology.OpenPartialHomeomorph.Composition | ∀ {X : Type u_2} {Y : Type u_1} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (e : OpenPartialHomeomorph X Y) (e' : OpenPartialHomeomorph Y Z),
(e.symm.restrOpen e'.source ⋯).symm.target = (e'.restrOpen e.target ⋯).source | null | false |
PositiveLinearMap.instAddCommMonoid._proof_4 | Mathlib.Algebra.Order.Module.PositiveLinearMap | ∀ {R : Type u_1} {E₁ : Type u_2} {E₂ : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid E₁]
[inst_2 : PartialOrder E₁] [inst_3 : AddCommMonoid E₂] [inst_4 : PartialOrder E₂] [inst_5 : Module R E₁]
[inst_6 : Module R E₂] [inst_7 : IsOrderedAddMonoid E₂],
autoParam (∀ (x : E₁ →ₚ[R] E₂), 0 • x = 0) AddMonoid.ns... | null | false |
isClosed_sUnion | Mathlib.Topology.AlexandrovDiscrete | ∀ {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {S : Set (Set α)},
(∀ s ∈ S, IsClosed s) → IsClosed (⋃₀ S) | null | true |
CategoryTheory.Functor.whiskeringRight._proof_6 | Mathlib.CategoryTheory.Whiskering | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_4, u_1} C] (D : Type u_6)
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (E : Type u_3) [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
{X Y : CategoryTheory.Functor D E} (τ : X ⟶ Y) (X_1 Y_1 : CategoryTheory.Functor C D) (f : X_1 ⟶ Y_1),
CategoryTheory.Categor... | null | false |
_private.Mathlib.Tactic.SetNotationForOrder.0.Mathlib.Meta.SetNotationForOrder.elabSubsetLike | Mathlib.Tactic.SetNotationForOrder | Lean.Term → Lean.Term → Lean.Name → Lean.Name → Lean.Name → Lean.Name → Option Lean.Expr → Lean.Elab.TermElabM Lean.Expr | Elaborate a notation like `a ⊆ b` by elaborating `a` and `b`, and then deciding
based on their type whether to return `a ⊆ b` or `a ≤ b`.
Use `a ≤ b` whenever `useSetNotationFor` returns true for the type.
If the type is not known, elaboration of this term is postponed.
We assume that `le` and `sub` are names for decl... | true |
String.Slice.Pattern.Model.Char.isLongestMatch_iff | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestMatch c pos ↔
∃ (h : s.startPos ≠ s.endPos), pos = s.startPos.next h ∧ s.startPos.get h = c | null | true |
Std.Sat.AIG.RefVec.map.go_decl_eq._unary | Std.Sat.AIG.RefVecOperator.Map | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ}
(f : (aig : Std.Sat.AIG α) → aig.Ref → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.Ref f] [inst_3 : Std.Sat.AIG.RefVec.LawfulMapOperator α f]
(_x : (aig : Std.Sat.AIG α) ×' (i : ℕ) ×' (_ : i ≤ len) ×' (_ : aig.Ref... | null | false |
BooleanSubalgebra.rec | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} →
[inst : BooleanAlgebra α] →
{motive : BooleanSubalgebra α → Sort u} →
((toSublattice : Sublattice α) →
(compl_mem' : ∀ {a : α}, a ∈ toSublattice.carrier → aᶜ ∈ toSublattice.carrier) →
(bot_mem' : ⊥ ∈ toSublattice.carrier) →
motive { toSublattice := toSubl... | null | false |
_private.Mathlib.Tactic.Inclusion.Core.DiscrTreeExt.0.DiscrTreeExt.evalDecl.unsafe_1 | Mathlib.Tactic.Inclusion.Core.DiscrTreeExt | (α : Type) → Lean.Name → Lean.Name → Lean.Environment → Lean.Options → ExceptT String Id α | null | true |
Nat.log_monotone | Mathlib.Data.Nat.Log | ∀ {b : ℕ}, Monotone (Nat.log b) | null | true |
Lean.Lsp.instFromJsonSemanticTokenModifier | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.SemanticTokenModifier | null | true |
StarMulEquiv.ext_iff | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} {B : Type u_3} [inst : Mul A] [inst_1 : Mul B] [inst_2 : Star A] [inst_3 : Star B] {f g : A ≃⋆* B},
f = g ↔ ∀ (a : A), f a = g a | null | true |
Qq.QuotedDefEq | Qq.Typ | {u : Lean.Level} → {α : Q(Sort u)} → Q(«$α») → Q(«$α») → Prop | `QuotedDefEq lhs rhs` says that the expressions `lhs` and `rhs` are definitionally equal.
You should usually write this using the notation `$lhs =Q $rhs`.
| true |
gc_sdiff_sup | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a : α}, GaloisConnection (fun x => x \ a) fun x => a ⊔ x | null | true |
intervalIntegral.norm_integral_min_max | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
(f : ℝ → E), ‖∫ (x : ℝ) in min a b..max a b, f x ∂μ‖ = ‖∫ (x : ℝ) in a..b, f x ∂μ‖ | null | true |
MvPolynomial.IsWeightedHomogeneous | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | {R : Type u_1} →
{M : Type u_2} → [inst : CommSemiring R] → {σ : Type u_3} → [AddCommMonoid M] → (σ → M) → MvPolynomial σ R → M → Prop | A multivariate polynomial `φ` is weighted homogeneous of weighted degree `m` if all monomials
occurring in `φ` have weighted degree `m`. | true |
Behrend.ceil_lt_mul | Mathlib.Combinatorics.Additive.AP.Three.Behrend | ∀ {x : ℝ}, 50 / 19 ≤ x → ↑⌈x⌉₊ < 1.38 * x | null | true |
_private.Mathlib.Data.List.Defs.0.List.length_mapAccumr.match_1_1 | Mathlib.Data.List.Defs | ∀ {α : Type u_3} {β : Type u_2} {γ : Type u_1} (motive : (α → γ → γ × β) → List α → γ → Prop) (x : α → γ → γ × β)
(x_1 : List α) (x_2 : γ),
(∀ (f : α → γ → γ × β) (head : α) (x : List α) (s : γ), motive f (head :: x) s) →
(∀ (x : α → γ → γ × β) (x_3 : γ), motive x [] x_3) → motive x x_1 x_2 | null | false |
Lean.Doc.CodeBlockSuggestion.casesOn | Lean.Elab.DocString | {motive : Lean.Doc.CodeBlockSuggestion → Sort u} →
(t : Lean.Doc.CodeBlockSuggestion) →
((name : Lean.Name) →
(args moreInfo : Option String) → motive { name := name, args := args, moreInfo := moreInfo }) →
motive t | null | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.elabNoMatch.loop._sunfold | Lean.Elab.Match | Lean.Syntax → List Lean.Term → Array Lean.Syntax → Lean.Elab.TermElabM Lean.Term | null | false |
PowerSeries.hasEvalIdeal.eq_1 | Mathlib.RingTheory.PowerSeries.Evaluation | ∀ {S : Type u_2} [inst : CommRing S] [inst_1 : TopologicalSpace S] [inst_2 : IsTopologicalRing S]
[inst_3 : IsLinearTopology S S],
PowerSeries.hasEvalIdeal = { carrier := {a | PowerSeries.HasEval a}, add_mem' := ⋯, zero_mem' := ⋯, smul_mem' := ⋯ } | null | true |
CategoryTheory.ObjectProperty.limitsClosure_top | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Type t} (J : α → Type u')
[inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)], ⊤.limitsClosure J = ⊤ | null | true |
Mathlib.Tactic.Order.ToInt.toInt_nlt_toInt | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u_1} [inst : LinearOrder α] {n : ℕ} (val : Fin n → α) (i j : Fin n),
¬Mathlib.Tactic.Order.ToInt.toInt val i < Mathlib.Tactic.Order.ToInt.toInt val j ↔ ¬val i < val j | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Clique.0.SimpleGraph.cliqueFreeOn_two._simp_1_7 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | null | false |
Rep.quotientToInvariantsFunctor._proof_4 | Mathlib.RepresentationTheory.Invariants | ∀ {G : Type u_1} [inst : Group G], SubmonoidClass (Subgroup G) G | null | false |
BitVec.getLsbD_reverse | Init.Data.BitVec.Lemmas | ∀ {w i : ℕ} {x : BitVec w}, x.reverse.getLsbD i = x.getMsbD i | null | true |
IsSymmetricAlgebra.lift_eq | Mathlib.LinearAlgebra.SymmetricAlgebra.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {A : Type u_3}
[inst_3 : CommSemiring A] [inst_4 : Algebra R A] {f : M →ₗ[R] A} (h : IsSymmetricAlgebra f) {A' : Type u_4}
[inst_5 : CommSemiring A'] [inst_6 : Algebra R A'] (g : M →ₗ[R] A') (a : M), (h.lift g) ... | null | true |
HahnSeries.instLinearOrderLex | Mathlib.RingTheory.HahnSeries.Lex | {Γ : Type u_1} →
{R : Type u_2} → [inst : LinearOrder Γ] → [inst_1 : Zero R] → [LinearOrder R] → LinearOrder (Lex (HahnSeries Γ R)) | null | true |
Multiplicative.preorder._proof_1 | Mathlib.Algebra.Order.Monoid.Unbundled.TypeTags | ∀ {α : Type u_1} [inst : Preorder α] (a : Multiplicative α), a ≤ a | null | false |
LinearIsometryEquiv._sizeOf_inst | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
{inst : Semiring R} →
{inst_1 : Semiring R₂} →
(σ₁₂ : R →+* R₂) →
{σ₂₁ : R₂ →+* R} →
{inst_2 : RingHomInvPair σ₁₂ σ₂₁} →
{inst_3 : RingHomInvPair σ₂₁ σ₁₂} →
(E : Type u_9) →
(E₂ : Type u_10) →
... | null | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.sum_Icc_sub._proof_1_11 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n : ℕ} {b : Fin n}, ↑b + 1 < n + 1 | null | false |
MulOpposite.op_le_op._simp_2 | Mathlib.Algebra.Order.Group.Opposite | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (MulOpposite.op a ≤ MulOpposite.op b) = (a ≤ b) | null | false |
Std.TreeSet._sizeOf_inst | Std.Data.TreeSet.Basic | (α : Type u) → (cmp : autoParam (α → α → Ordering) Std.TreeSet._auto_1) → [SizeOf α] → SizeOf (Std.TreeSet α cmp) | null | false |
ContinuousMap.instNorm | Mathlib.Topology.ContinuousMap.Compact | {α : Type u_1} →
{E : Type u_3} → [inst : TopologicalSpace α] → [CompactSpace α] → [inst_2 : SeminormedAddCommGroup E] → Norm C(α, E) | null | true |
neg_sub_neg | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α), -a - -b = b - a | null | true |
LineDeriv.iteratedLineDerivOp_fin_zero | Mathlib.Analysis.Distribution.DerivNotation | ∀ {V : Type u_9} {E : Type u_10} [inst : LineDeriv V E E] (m : Fin 0 → V) (f : E), LineDeriv.iteratedLineDerivOp m f = f | null | true |
Lean.Elab.Tactic.BVDecide.BVDecideConfig.ctorIdx | Std.Tactic.BVDecide.Syntax | Lean.Elab.Tactic.BVDecide.BVDecideConfig → ℕ | null | false |
_private.Mathlib.LinearAlgebra.Span.Defs.0.Submodule.mem_sSup_of_directed._simp_1_1 | Mathlib.LinearAlgebra.Span.Defs | ∀ {α : Type u} {s : Set α} {p : ↑s → Prop}, (∃ x, p x) = ∃ x, ∃ (h : x ∈ s), p ⟨x, h⟩ | null | false |
MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_Bochner_Basic___macroRules_MeasureTheory_term∫_,_∂__1» | Mathlib.MeasureTheory.Integral.Bochner.Basic | Lean.Macro | null | false |
Std.DTreeMap.get?_inter_of_not_mem_left | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {k : α}, k ∉ t₁ → (t₁ ∩ t₂).get? k = none | null | true |
MeasureTheory.Integrable.comp_snd_iff | Mathlib.MeasureTheory.Integral.Prod | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E] [MeasureTheory.SFinite ν]
[MeasureTheory.IsFiniteMeasure μ] {f : β → E},
μ ≠ 0 → (MeasureTheory.Integrable (fun x => f ... | null | true |
Multiset.chooseX | Mathlib.Data.Multiset.Basic | {α : Type u_1} → (p : α → Prop) → [DecidablePred p] → (l : Multiset α) → (∃! a, a ∈ l ∧ p a) → { a // a ∈ l ∧ p a } | Given a proof `hp` that there exists a unique `a ∈ l` such that `p a`, `chooseX p l hp` returns
that `a` together with proofs of `a ∈ l` and `p a`. | true |
ExtremallyDisconnected.open_closure | Mathlib.Topology.ExtremallyDisconnected | ∀ {X : Type u} {inst : TopologicalSpace X} [self : ExtremallyDisconnected X] (U : Set X), IsOpen U → IsOpen (closure U) | The closure of every open set is open. | true |
_private.Mathlib.Tactic.Linter.EmptyLine.0.Mathlib.Linter.EmptyLine.emptyLineLinter.match_1 | Mathlib.Tactic.Linter.EmptyLine | (motive : Lean.MessageSeverity → Sort u_1) →
(x : Lean.MessageSeverity) →
(Unit → motive Lean.MessageSeverity.information) → ((x : Lean.MessageSeverity) → motive x) → motive x | null | false |
Lean.Lsp.FileEvent | Lean.Data.Lsp.Workspace | Type | null | true |
CategoryTheory.Limits.isoBiprodZero_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (hY : CategoryTheory.Limits.IsZero Y),
(CategoryTheory.Limits.isoBiprodZero hY).inv = CategoryTheory.Limits.biprod.fst | null | true |
IsometryEquiv.divRight_toEquiv | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : Group G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricSMul Gᵐᵒᵖ G] (c : G),
(IsometryEquiv.divRight c).toEquiv = Equiv.divRight c | null | true |
Matroid.isRkFinite_iff_exists_isBasis' | Mathlib.Combinatorics.Matroid.Rank.Finite | ∀ {α : Type u_1} {M : Matroid α} {X : Set α}, M.IsRkFinite X ↔ ∃ I, M.IsBasis' I X ∧ I.Finite | A set satisfies `IsRkFinite` iff it has a finite basis' | true |
HomotopicalAlgebra.Precylinder.op_p₁ | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P : HomotopicalAlgebra.Precylinder A),
P.op.p₁ = P.i₁.op | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput.casesOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{motive : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig → Sort u} →
(t : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig) →
((w : ℕ) → (vec : aig.BinaryRefVec w) → (cin : aig.Ref... | null | false |
Std.DHashMap.Internal.Raw₀.wfImp_insertMany | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {ρ : Type w}
[inst_4 : ForIn Id ρ ((a : α) × β a)] {m : Std.DHashMap.Internal.Raw₀ α β} {l : ρ},
Std.DHashMap.Internal.Raw.WFImp ↑m → Std.DHashMap.Internal.Raw.WFImp ↑↑(m.insertMany l) | null | true |
Field.Emb.Cardinal.succEquiv._proof_7 | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E]
(i : (Module.rank F E).ord.ToType),
IsScalarTower F
↥(IntermediateField.adjoin F
(⇑(Field.Emb.Cardinal.wellOrderedBasis F ... | null | false |
RelHom.id_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} (r : α → α → Prop) (x : α), (RelHom.id r) x = x | null | true |
Cardinal.nat_le_lift_iff._simp_1 | Mathlib.SetTheory.Cardinal.Order | ∀ {n : ℕ} {a : Cardinal.{u}}, (↑n ≤ Cardinal.lift.{v, u} a) = (↑n ≤ a) | null | false |
MvPFunctor.WPath._sizeOf_inst | Mathlib.Data.PFunctor.Multivariate.W | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → (a : P.last.W) → (a_1 : Fin2 n) → SizeOf (P.WPath a a_1) | null | false |
CategoryTheory.Pi.laxMonoidalPi._proof_10 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : I → Type u_5}
[inst_2 : (i : I) → CategoryTheory.Category.{u_4, u_5} (D i)]
[inst_3 : (i : I) → CategoryTheory.MonoidalCategory (D i)] (F : (i : I) → Cate... | null | false |
EuclideanGeometry.Sphere.IsDiameter.midpoint_eq_center | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
s.IsDiameter p₁ p₂ → midpoint ℝ p₁ p₂ = s.center | null | true |
Dilation.ratio_comp' | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
[inst_2 : PseudoEMetricSpace γ] {g : β →ᵈ γ} {f : α →ᵈ β},
(∃ x y, edist x y ≠ 0 ∧ edist x y ≠ ⊤) → Dilation.ratio (g.comp f) = Dilation.ratio g * Dilation.ratio f | Ratio of the composition `g.comp f` of two dilations is the product of their ratios. We assume
that there exist two points in `α` at extended distance neither `0` nor `∞` because otherwise
`Dilation.ratio (g.comp f) = Dilation.ratio f = 1` while `Dilation.ratio g` can be any number. This
version works for most general ... | true |
Nat.count_le_cardinal | Mathlib.SetTheory.Cardinal.NatCount | ∀ {p : ℕ → Prop} [inst : DecidablePred p] (n : ℕ), ↑(Nat.count p n) ≤ Cardinal.mk ↑{k | p k} | null | true |
Aesop.GoalUnsafe.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.GoalUnsafe} → t = t' → Aesop.GoalUnsafe.noConfusionType P t t' | null | false |
_private.Mathlib.Tactic.CategoryTheory.Elementwise.0.Mathlib.Tactic.Elementwise.initFn.match_1._@.Mathlib.Tactic.CategoryTheory.Elementwise.3754623819._hygCtx._hyg.2 | Mathlib.Tactic.CategoryTheory.Elementwise | (motive : Option (Lean.Level × Lean.Level) → Sort u_1) →
(level? : Option (Lean.Level × Lean.Level)) →
((levelW levelUF : Lean.Level) → motive (some (levelW, levelUF))) →
((x : Option (Lean.Level × Lean.Level)) → motive x) → motive level? | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.DefEqM.Context._sizeOf_1 | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.DefEqM.Context✝ → ℕ | null | false |
_private.Mathlib.AlgebraicGeometry.Cover.Open.0.AlgebraicGeometry.Scheme.OpenCover.ext_elem._simp_1_2 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Std.DHashMap.Internal.Raw₀.contains_diff_eq_false_of_contains_eq_false_left | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → ∀ {k : α}, m₁.contains k = false → (m₁.diff m₂).contains k = false | null | true |
SpecialLinearGroup.instGroup._proof_10 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
(a : SpecialLinearGroup R V), a⁻¹ * a = 1 | null | false |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.rightHomologyData._proof_7 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H ... | null | false |
Std.Do.PostShape.pure.sizeOf_spec | Std.Do.PostCond | sizeOf Std.Do.PostShape.pure = 1 | null | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.preimage_mul_const_Icc_of_neg._simp_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Icc a b = Set.Ici a ∩ Set.Iic b | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Semisimple.0.LinearMap.IsSymmetric.isFinitelySemisimple._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Semisimple | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree.0.WeierstrassCurve.natDegree_preΨ'_pos._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {a b : ℕ}, (0 < a / b) = (0 < b ∧ b ≤ a) | null | false |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkEqTrans?.match_1 | Lean.Meta.AppBuilder | (motive : Option Lean.Expr → Option Lean.Expr → Sort u_1) →
(h₁? h₂? : Option Lean.Expr) →
(Unit → motive none none) →
((h : Lean.Expr) → motive none (some h)) →
((h : Lean.Expr) → motive (some h) none) → ((h₁ h₂ : Lean.Expr) → motive (some h₁) (some h₂)) → motive h₁? h₂? | null | false |
Std.ExtTreeMap.getD_ofList_of_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
∀ {v fallback : β},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
(k, v) ∈ l → (Std.ExtTreeMap.ofList l cmp).getD k' fallback = v | null | true |
_private.Mathlib.Order.Interval.Set.Card.0.Set.encard_Ioi._simp_1_1 | Mathlib.Order.Interval.Set.Card | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] (a : α), Set.Ioi a = ↑(Finset.Ioi a) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.