name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Equiv.setCongr | Mathlib.Logic.Equiv.Set | {α : Type u_3} → {s t : Set α} → s = t → ↑s ≃ ↑t |
_private.Mathlib.GroupTheory.SpecificGroups.Dihedral.0.instDecidableEqDihedralGroup.decEq.match_1.eq_4 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (motive : DihedralGroup n → DihedralGroup n → Sort u_1) (a b : ZMod n)
(h_1 : (a b : ZMod n) → motive (DihedralGroup.r a) (DihedralGroup.r b))
(h_2 : (a a_1 : ZMod n) → motive (DihedralGroup.r a) (DihedralGroup.sr a_1))
(h_3 : (a a_1 : ZMod n) → motive (DihedralGroup.sr a) (DihedralGroup.r a_1))
(h_4 : (a b : ZMod n) → motive (DihedralGroup.sr a) (DihedralGroup.sr b)),
(match DihedralGroup.sr a, DihedralGroup.sr b with
| DihedralGroup.r a, DihedralGroup.r b => h_1 a b
| DihedralGroup.r a, DihedralGroup.sr a_1 => h_2 a a_1
| DihedralGroup.sr a, DihedralGroup.r a_1 => h_3 a a_1
| DihedralGroup.sr a, DihedralGroup.sr b => h_4 a b) =
h_4 a b |
Nat.getD_toList_ric_eq_fallback | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i fallback : ℕ}, n < i → (*...=n).toList.getD i fallback = fallback |
_private.Mathlib.Topology.UniformSpace.Compact.0.IsClosed.relPreimage_of_isCompact._simp_1_1 | Mathlib.Topology.UniformSpace.Compact | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) |
SSet.instFiniteObjOppositeSimplexCategoryTensorObj | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | ∀ (X Y : SSet) (n : SimplexCategoryᵒᵖ) [Finite (X.obj n)] [Finite (Y.obj n)],
Finite ((CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).obj n) |
antitone_toDual_comp_iff | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Antitone (⇑OrderDual.toDual ∘ f) ↔ Monotone f |
MulEquiv.piMultiplicative._proof_2 | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {ι : Type u_1} (K : ι → Type u_2),
Function.RightInverse (fun x => Multiplicative.ofAdd fun i => Multiplicative.toAdd (x i)) fun x i =>
Multiplicative.ofAdd (Multiplicative.toAdd x i) |
_private.Mathlib.MeasureTheory.Constructions.BorelSpace.Basic.0.Pi.opensMeasurableSpace_of_subsingleton._simp_2 | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [t : TopologicalSpace β] {f : α → β} {s : Set α},
IsOpen s = (s ∈ Set.preimage f '' {s | IsOpen s}) |
_private.Init.Data.BitVec.Lemmas.0.BitVec.shiftLeft_eq_concat_of_lt._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ}, ∀ i < w, ¬i < n → ¬i - n < w → False |
ContDiffMapSupportedIn._sizeOf_inst | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | (E : Type u_2) →
(F : Type u_3) →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} →
{inst_2 : NormedAddCommGroup F} →
{inst_3 : NormedSpace ℝ F} →
(n : ℕ∞) →
(K : TopologicalSpace.Compacts E) → [SizeOf E] → [SizeOf F] → SizeOf (ContDiffMapSupportedIn E F n K) |
Rep.indCoindIso | Mathlib.RepresentationTheory.FiniteIndex | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
{S : Subgroup G} →
[DecidableRel ⇑(QuotientGroup.rightRel S)] →
(A : Rep k ↥S) → [S.FiniteIndex] → Rep.ind S.subtype A ≅ Rep.coind S.subtype A |
_private.Mathlib.Combinatorics.SetFamily.AhlswedeZhang.0.Finset.sups_aux | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : DecidableEq α] {s t : Finset α} {a : α},
a ∈ upperClosure ↑(s ⊻ t) ↔ a ∈ upperClosure ↑s ∧ a ∈ upperClosure ↑t |
List.reverseAux_reverseAux_nil | Init.Data.List.Lemmas | ∀ {α : Type u_1} {as bs : List α}, (as.reverseAux bs).reverseAux [] = bs.reverseAux as |
Lean.Meta.Grind.EMatchTheoremConstraint.guard.injEq | Lean.Meta.Tactic.Grind.Extension | ∀ (e e_1 : Lean.Expr),
(Lean.Meta.Grind.EMatchTheoremConstraint.guard e = Lean.Meta.Grind.EMatchTheoremConstraint.guard e_1) = (e = e_1) |
CategoryTheory.eHom_whisker_cancel_inv | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | ∀ (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] {X Y Y₁ Z : C}
(α : Y ≅ Y₁),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.eHomWhiskerLeft V X α.inv) (Y₁ ⟶[V] Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (X ⟶[V] Y) (CategoryTheory.eHomWhiskerRight V α.hom Z))
(CategoryTheory.eComp V X Y Z)) =
CategoryTheory.eComp V X Y₁ Z |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.Forall.match_1.eq_1 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_2} (motive : (x : ℕ) → ((Fin x → α) → Prop) → Sort u_1) (P : (Fin 0 → α) → Prop)
(h_1 : (P : (Fin 0 → α) → Prop) → motive 0 P) (h_2 : (n : ℕ) → (P : (Fin (n + 1) → α) → Prop) → motive n.succ P),
(match 0, P with
| 0, P => h_1 P
| n.succ, P => h_2 n P) =
h_1 P |
Module.Basis.range_extend | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V}
(hs : LinearIndepOn K id s), Set.range ⇑(Module.Basis.extend hs) = hs.extend ⋯ |
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.Lean.Meta.Grind.AC.withExprs.go.match_1.eq_2 | Lean.Meta.Tactic.Grind.AC.Eq | ∀ (motive : List ℕ → List ℕ → Sort u_1) (x : List ℕ) (h_1 : (x : List ℕ) → motive [] x)
(h_2 : (x : List ℕ) → motive x [])
(h_3 : (id₁ : ℕ) → (ids₁ : List ℕ) → (id₂ : ℕ) → (ids₂ : List ℕ) → motive (id₁ :: ids₁) (id₂ :: ids₂)),
(x = [] → False) →
(match x, [] with
| [], x => h_1 x
| x, [] => h_2 x
| id₁ :: ids₁, id₂ :: ids₂ => h_3 id₁ ids₁ id₂ ids₂) =
h_2 x |
NonUnitalSubsemiring.prodEquiv | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring S] →
(s : NonUnitalSubsemiring R) → (t : NonUnitalSubsemiring S) → ↥(s.prod t) ≃+* ↥s × ↥t |
Std.TreeMap.Raw.contains_iff_mem._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} {k : α},
(t.contains k = true) = (k ∈ t) |
Lean.Elab.Command.InductiveElabStep2 | Lean.Elab.MutualInductive | Type |
_private.Mathlib.Tactic.CategoryTheory.Elementwise.0.Mathlib.Tactic.Elementwise.mkUnusedName.loop | Mathlib.Tactic.CategoryTheory.Elementwise | List Lean.Name → Lean.Name → optParam ℕ 0 → Lean.Name |
Lean.Meta.Grind.AC.ProofM.State.exprDecls | Lean.Meta.Tactic.Grind.AC.Proof | Lean.Meta.Grind.AC.ProofM.State → Std.HashMap Lean.Grind.AC.Expr Lean.Expr |
Lean.Parser.Module.prelude | Lean.Parser.Module | Lean.Parser.Parser |
Array.getElem_toList | Init.Data.Array.Basic | ∀ {α : Type u} {xs : Array α} {i : ℕ} (h : i < xs.size), xs.toList[i] = xs[i] |
_private.Init.Data.Iterators.Lemmas.Consumers.Collect.0.Std.Iter.atIdxSlow?.match_1.eq_2 | Init.Data.Iterators.Lemmas.Consumers.Collect | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β)
(motive :
(n : ℕ) →
((a' : Std.Iter β) →
(b' : ℕ) →
InvImage (Prod.Lex WellFoundedRelation.rel Std.IterM.TerminationMeasures.Productive.Rel)
(fun p => (p.snd, p.fst.finitelyManySkips!)) ⟨a', b'⟩ ⟨it, n⟩ →
(fun x x_1 => Option β) a' b') →
Sort u_2)
(k : ℕ)
(recur :
(a' : Std.Iter β) →
(b' : ℕ) →
InvImage (Prod.Lex WellFoundedRelation.rel Std.IterM.TerminationMeasures.Productive.Rel)
(fun p => (p.snd, p.fst.finitelyManySkips!)) ⟨a', b'⟩ ⟨it, k + 1⟩ →
(fun x x_1 => Option β) a' b')
(h_1 :
(recur :
(a' : Std.Iter β) →
(b' : ℕ) →
InvImage (Prod.Lex WellFoundedRelation.rel Std.IterM.TerminationMeasures.Productive.Rel)
(fun p => (p.snd, p.fst.finitelyManySkips!)) ⟨a', b'⟩ ⟨it, 0⟩ →
(fun x x_1 => Option β) a' b') →
motive 0 recur)
(h_2 :
(k : ℕ) →
(recur :
(a' : Std.Iter β) →
(b' : ℕ) →
InvImage (Prod.Lex WellFoundedRelation.rel Std.IterM.TerminationMeasures.Productive.Rel)
(fun p => (p.snd, p.fst.finitelyManySkips!)) ⟨a', b'⟩ ⟨it, k + 1⟩ →
(fun x x_1 => Option β) a' b') →
motive k.succ recur),
(match k.succ, recur with
| 0, recur => h_1 recur
| k.succ, recur => h_2 k recur) =
h_2 k recur |
Aesop.PatSubstSource.casesOn | Aesop.Forward.State | {motive : Aesop.PatSubstSource → Sort u} →
(t : Aesop.PatSubstSource) →
((fvarId : Lean.FVarId) → motive (Aesop.PatSubstSource.hyp fvarId)) → motive Aesop.PatSubstSource.target → motive t |
LieHom.mem_idealRange_iff._simp_1 | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] (f : L →ₗ⁅R⁆ L'),
f.IsIdealMorphism → ∀ {y : L'}, (y ∈ f.idealRange) = ∃ x, f x = y |
MeasureTheory.innerRegular_map_add_left | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : AddGroup G] [IsTopologicalAddGroup G] [μ.InnerRegular] (g : G),
(MeasureTheory.Measure.map (fun x => g + x) μ).InnerRegular |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_of_finite._simp_1_2 | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (g : M)
(r : R), (r ∈ (R ∙ g).annihilator) = (r • g = 0) |
CategoryTheory.ObjectProperty.strictLimitsOfShape_monotone | Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.ObjectProperty C} (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] {Q : CategoryTheory.ObjectProperty C},
P ≤ Q → P.strictLimitsOfShape J ≤ Q.strictLimitsOfShape J |
List.eraseIdx_modify_of_eq | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (i : ℕ) (l : List α), (l.modify i f).eraseIdx i = l.eraseIdx i |
ULift.ring._proof_3 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : Ring R] (n : ℕ) (a : ULift.{u_1, u_2} R),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a |
AEMeasurable.cexp | Mathlib.MeasureTheory.Function.SpecialFunctions.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℂ},
AEMeasurable f μ → AEMeasurable (fun x => Complex.exp (f x)) μ |
Sym2.hrec._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {motive : Sym2 α → Sort u_2} (f : (a b : α) → motive s(a, b)),
(∀ (a b : α), f a b ≍ f b a) →
∀ (a b : α × α),
Sym2.Rel α a b →
(fun x =>
match x with
| (a, b) => f a b)
a ≍
(fun x =>
match x with
| (a, b) => f a b)
b |
_private.Init.WFComputable.0.Acc.recC._unary._proof_6 | Init.WFComputable | ∀ {α : Sort u_1} {r : α → α → Prop} (y : (a : α) ×' Acc r a), Acc r y.1 |
Lean.MonadFileMap.noConfusion | Lean.Data.Position | {P : Sort u} →
{m : Type → Type} →
{t : Lean.MonadFileMap m} →
{m' : Type → Type} → {t' : Lean.MonadFileMap m'} → m = m' → t ≍ t' → Lean.MonadFileMap.noConfusionType P t t' |
String.Slice.Subslice.noConfusionType | Init.Data.String.Subslice | Sort u → {s : String.Slice} → s.Subslice → {s' : String.Slice} → s'.Subslice → Sort u |
Polynomial.aeval.eq_1 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A),
Polynomial.aeval x = Polynomial.eval₂AlgHom' (Algebra.ofId R A) x ⋯ |
CategoryTheory.JointlyFaithful.map_injective | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {I : Type u_2} {D : I → Type u_3}
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] {F : (i : I) → CategoryTheory.Functor C (D i)},
CategoryTheory.JointlyFaithful F → ∀ {X Y : C} {f g : X ⟶ Y}, (∀ (i : I), (F i).map f = (F i).map g) → f = g |
TopCat.Presheaf.isSheaf_on_punit_iff_isTerminal | Mathlib.Topology.Sheaves.PUnit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : TopCat.Presheaf C { carrier := PUnit.{u_1 + 1}, str := instTopologicalSpacePUnit }),
F.IsSheaf ↔ Nonempty (CategoryTheory.Limits.IsTerminal (F.obj (Opposite.op ⊥))) |
CategoryTheory.ShortComplex.homologyMap_smul | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_1} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(φ : S₁ ⟶ S₂) (a : R) [inst_4 : S₁.HasHomology] [inst_5 : S₂.HasHomology],
CategoryTheory.ShortComplex.homologyMap (a • φ) = a • CategoryTheory.ShortComplex.homologyMap φ |
Nat.gcd_mul_left_sub_right | Init.Data.Nat.Gcd | ∀ {m n k : ℕ}, n ≤ m * k → m.gcd (m * k - n) = m.gcd n |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValue_filter_not_contains._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValue a l h) = Std.Internal.List.getValue? a l |
Mathlib.Tactic.Translate.etaExpandN | Mathlib.Tactic.Translate.Core | ℕ → Lean.Expr → Lean.MetaM Lean.Expr |
Lean.Parser.Term.letrec._regBuiltin.Lean.Parser.Termination.partialFixpoint.formatter_35 | Lean.Parser.Term | IO Unit |
Cardinal.add_nat_inj | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {α β : Cardinal.{u_1}} (n : ℕ), α + ↑n = β + ↑n ↔ α = β |
_private.Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors.0.MonoidAlgebra.instIsLeftCancelMulZeroOfIsCancelAddOfUniqueProds._simp_3 | Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | ∀ {G : Type u_1} [inst : Add G] [IsRightCancelAdd G] {a b c : G}, (b + a = c + a) = (b = c) |
TopologicalSpace.OpenNhdsOf.rec | Mathlib.Topology.Sets.Opens | {α : Type u_2} →
[inst : TopologicalSpace α] →
{x : α} →
{motive : TopologicalSpace.OpenNhdsOf x → Sort u} →
((toOpens : TopologicalSpace.Opens α) →
(mem' : x ∈ toOpens.carrier) → motive { toOpens := toOpens, mem' := mem' }) →
(t : TopologicalSpace.OpenNhdsOf x) → motive t |
HomologicalComplex.Hom.comm_from | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : C₁.Hom C₂) (i : ι),
CategoryTheory.CategoryStruct.comp (f.f i) (C₂.dFrom i) = CategoryTheory.CategoryStruct.comp (C₁.dFrom i) (f.next i) |
_private.Mathlib.Order.Nucleus.0.Nucleus.range.instFrameMinimalAxioms._simp_1 | Mathlib.Order.Nucleus | ∀ {α : Type u_2} [inst : LE α] {p : α → Prop} {x y : Subtype p}, (x ≤ y) = (↑x ≤ ↑y) |
StarMonoidHom.coe_one | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} [inst : Monoid A] [inst_1 : Star A], ⇑1 = id |
CategoryTheory.Bicategory.leftAdjointSquare.comp_hvcomp | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d e f x y z : B} {g₁ : a ⟶ d} {h₁ : b ⟶ e} {k₁ : c ⟶ f}
{g₂ : d ⟶ x} {h₂ : e ⟶ y} {k₂ : f ⟶ z} {l₁ : a ⟶ b} {l₂ : b ⟶ c} {l₃ : d ⟶ e} {l₄ : e ⟶ f} {l₅ : x ⟶ y} {l₆ : y ⟶ z}
(α : CategoryTheory.CategoryStruct.comp g₁ l₃ ⟶ CategoryTheory.CategoryStruct.comp l₁ h₁)
(β : CategoryTheory.CategoryStruct.comp h₁ l₄ ⟶ CategoryTheory.CategoryStruct.comp l₂ k₁)
(γ : CategoryTheory.CategoryStruct.comp g₂ l₅ ⟶ CategoryTheory.CategoryStruct.comp l₃ h₂)
(δ : CategoryTheory.CategoryStruct.comp h₂ l₆ ⟶ CategoryTheory.CategoryStruct.comp l₄ k₂),
CategoryTheory.Bicategory.leftAdjointSquare.comp α β γ δ =
CategoryTheory.Bicategory.leftAdjointSquare.hcomp (CategoryTheory.Bicategory.leftAdjointSquare.vcomp α γ)
(CategoryTheory.Bicategory.leftAdjointSquare.vcomp β δ) |
PowerSeries.derivative_invOf | Mathlib.RingTheory.PowerSeries.Derivative | ∀ {R : Type u_1} [inst : CommRing R] (f : PowerSeries R) [inst_1 : Invertible f],
(PowerSeries.derivative R) ⅟f = -⅟f ^ 2 * (PowerSeries.derivative R) f |
DerivedCategory.triangleOfSESδ._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.ShortExact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex (CochainComplex C ℤ)} (i : ℤ),
(HomologicalComplex.sc (CochainComplex.mappingCone S.f) i).HasHomology |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.State.iPending | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.UnifyM.State✝ → Array (Lean.Expr × Lean.Expr) |
Std.DHashMap.contains_of_contains_insertIfNew' | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{k a : α} {v : β k},
(m.insertIfNew k v).contains a = true → ¬((k == a) = true ∧ m.contains k = false) → m.contains a = true |
Finite.equivFinOfCardEq | Mathlib.Data.Finite.Card | {α : Type u_1} → [Finite α] → {n : ℕ} → Nat.card α = n → α ≃ Fin n |
NonUnitalSubring.center.instNonUnitalCommRing._proof_11 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ (R : Type u_1) [inst : NonUnitalNonAssocRing R] (a b c : ↥(NonUnitalSubsemiring.center R)), a * b * c = a * (b * c) |
WithTop.le_coe_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithTop α}, x ≤ ↑a ↔ ∃ b, x = ↑b ∧ b ≤ a |
IsNowhereDense.closure | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsNowhereDense s → IsNowhereDense (closure s) |
Real.«term√_» | Mathlib.Data.Real.Sqrt | Lean.ParserDescr |
UniformSpace.Completion.map_comp | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {γ : Type u_3}
[inst_2 : UniformSpace γ] {g : β → γ} {f : α → β},
UniformContinuous g →
UniformContinuous f →
UniformSpace.Completion.map g ∘ UniformSpace.Completion.map f = UniformSpace.Completion.map (g ∘ f) |
MeasureTheory.Measure.join_zero | Mathlib.MeasureTheory.Measure.GiryMonad | ∀ {α : Type u_1} {mα : MeasurableSpace α}, MeasureTheory.Measure.join 0 = 0 |
Std.Internal.List.getValueCast_eraseKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {k a : α}
{h : Std.Internal.List.containsKey a (Std.Internal.List.eraseKey k l) = true} (hl : Std.Internal.List.DistinctKeys l),
Std.Internal.List.getValueCast a (Std.Internal.List.eraseKey k l) h = Std.Internal.List.getValueCast a l ⋯ |
continuous_cfcₙHom_of_cfcHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Ring A] [inst_6 : StarRing A]
[inst_7 : TopologicalSpace A] [inst_8 : Algebra R A] [inst_9 : ContinuousFunctionalCalculus R A p] {a : A} (ha : p a),
Continuous ⇑(cfcₙHom_of_cfcHom R ha) |
Int16.ne_of_lt | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, a < b → a ≠ b |
Lean.Meta.Try.Collector.OrdSet.rec | Lean.Meta.Tactic.Try.Collect | {α : Type} →
[inst : Hashable α] →
[inst_1 : BEq α] →
{motive : Lean.Meta.Try.Collector.OrdSet α → Sort u} →
((elems : Array α) → (set : Std.HashSet α) → motive { elems := elems, set := set }) →
(t : Lean.Meta.Try.Collector.OrdSet α) → motive t |
_private.Lean.Elab.Tactic.Grind.Lint.0.Lean.Elab.Tactic.Grind.elabGrindLintInspect | Lean.Elab.Tactic.Grind.Lint | Lean.Elab.Command.CommandElab |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.isDone | Lean.Meta.Match.SimpH | Lean.Meta.Match.SimpH.M✝ Bool |
Nat.and_distrib_right | Init.Data.Nat.Bitwise.Lemmas | ∀ (x y z : ℕ), (x ||| y) &&& z = x &&& z ||| y &&& z |
CategoryTheory.Functor.IsCardinalAccessible.recOn | Mathlib.CategoryTheory.Presentable.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{κ : Cardinal.{w}} →
[inst_2 : Fact κ.IsRegular] →
{motive : F.IsCardinalAccessible κ → Sort u} →
(t : F.IsCardinalAccessible κ) →
((preservesColimitOfShape :
∀ (J : Type w) [inst_3 : CategoryTheory.SmallCategory J]
[CategoryTheory.IsCardinalFiltered J κ], CategoryTheory.Limits.PreservesColimitsOfShape J F) →
motive ⋯) →
motive t |
_private.Mathlib.Algebra.Lie.BaseChange.0.LieAlgebra.ExtendScalars.bracket'._proof_5 | Mathlib.Algebra.Lie.BaseChange | ∀ (R : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
IsScalarTower R A (TensorProduct A A A) |
_private.Lean.Meta.Match.CaseValues.0.Lean.Meta.caseValues.loop._sparseCasesOn_3 | Lean.Meta.Match.CaseValues | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
_private.Init.Omega.IntList.0.List.getElem?_zipWith.match_1.splitter | Init.Omega.IntList | {α : Type u_1} →
{β : Type u_2} →
(motive : Option α → Option β → Sort u_3) →
(x : Option α) →
(x_1 : Option β) →
((a : α) → (b : β) → motive (some a) (some b)) →
((x : Option α) →
(x_2 : Option β) → (∀ (a : α) (b : β), x = some a → x_2 = some b → False) → motive x x_2) →
motive x x_1 |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.toInductive | Lean.Meta.MkIffOfInductiveProp | Lean.MVarId → List Lean.Name → List Lean.Expr → List Lean.Meta.Shape✝ → Lean.FVarId → Lean.MetaM Unit |
ArchimedeanClass.closedBall_top | Mathlib.Algebra.Order.Module.Archimedean | ∀ (M : Type u_1) [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (K : Type u_2)
[inst_3 : Ring K] [inst_4 : LinearOrder K] [inst_5 : IsOrderedRing K] [inst_6 : Archimedean K] [inst_7 : Module K M]
[inst_8 : PosSMulMono K M], ArchimedeanClass.closedBall K ⊤ = ⊥ |
ProbabilityTheory.IdentDistrib.measure_preimage_eq | Mathlib.Probability.IdentDistrib | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ},
ProbabilityTheory.IdentDistrib f g μ ν → ∀ {s : Set γ}, MeasurableSet s → μ (f ⁻¹' s) = ν (g ⁻¹' s) |
_private.Mathlib.Data.Finsupp.MonomialOrder.DegLex.0.Finsupp.DegLex.single_strictAnti._simp_1_1 | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_2} [inst : Preorder α] (x : α), (x < x) = False |
NNReal.iSup_eq_zero | Mathlib.Data.NNReal.Defs | ∀ {ι : Sort u_1} {f : ι → NNReal}, BddAbove (Set.range f) → (⨆ i, f i = 0 ↔ ∀ (i : ι), f i = 0) |
DFinsupp.toMultiset_toDFinsupp | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] (f : Π₀ (x : α), ℕ), Multiset.toDFinsupp (DFinsupp.toMultiset f) = f |
_private.Mathlib.SetTheory.Cardinal.Finite.0.Nat.card_ne_zero._simp_1_2 | Mathlib.SetTheory.Cardinal.Finite | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) |
Int.Linear.le_of_le_diseq_cert.eq_1 | Init.Data.Int.Linear | ∀ (p₁ p₂ p₃ : Int.Linear.Poly),
Int.Linear.le_of_le_diseq_cert p₁ p₂ p₃ = (p₂.beq' p₁ || p₂.beq' (p₁.mul_k (-1))).and' (p₃.beq' (p₁.addConst_k 1)) |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.ProofM.State.varDecls' | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | Lean.Meta.Grind.Arith.Cutsat.ProofM.State✝ → Std.HashMap Int.Linear.Var Lean.Expr |
Cycle.coe_eq_coe._simp_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l₁ l₂ : List α}, (↑l₁ = ↑l₂) = (l₁ ~r l₂) |
NonUnitalSubring.toNonUnitalSubsemiring_strictMono | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R], StrictMono NonUnitalSubring.toNonUnitalSubsemiring |
ZeroAtInftyContinuousMap.instNormedAddCommGroup._proof_1 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {β : Type u_1} [inst : NormedAddCommGroup β], IsTopologicalAddGroup β |
RingHom.coe_rangeRestrict | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) (x : R), ↑(f.rangeRestrict x) = f x |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateBoxImp._sparseCasesOn_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((ty : Lean.Expr) →
(fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.LetValue.box ty fvarId h)) →
(Nat.hasNotBit 8192 t.ctorIdx → motive t) → motive t |
CategoryTheory.GradedNatTrans | 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] →
CategoryTheory.Center V →
CategoryTheory.EnrichedFunctor V C D → CategoryTheory.EnrichedFunctor V C D → Type (max u₁ w) |
CategoryTheory.Mat_.lift_map | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive]
{X Y : CategoryTheory.Mat_ C} (f : X ⟶ Y),
(CategoryTheory.Mat_.lift F).map f = CategoryTheory.Limits.biproduct.matrix fun i j => F.map (f i j) |
Batteries.Random.MersenneTwister.State.mk.inj | Batteries.Data.Random.MersenneTwister | ∀ {cfg : Batteries.Random.MersenneTwister.Config} {data : Vector (BitVec cfg.wordSize) cfg.stateSize}
{index : Fin cfg.stateSize} {data_1 : Vector (BitVec cfg.wordSize) cfg.stateSize} {index_1 : Fin cfg.stateSize},
{ data := data, index := index } = { data := data_1, index := index_1 } → data = data_1 ∧ index = index_1 |
CategoryTheory.Functor.Final.coconesEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u_2}
[inst_3 : CategoryTheory.Category.{u_1, u_2} E] (G : CategoryTheory.Functor D E)
(c : CategoryTheory.Limits.Cocone (F.comp G)) (j : C),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone (F.comp G))).obj c).ι.app j)
(CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone (F.comp G))).obj c).pt).hom =
((CategoryTheory.Functor.Final.extendCocone.comp (CategoryTheory.Limits.Cocones.whiskering F)).obj c).ι.app j |
MeasurableEmbedding.map_withDensity_rnDeriv | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α → β},
MeasurableEmbedding f →
∀ (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ] [MeasureTheory.SigmaFinite ν],
MeasureTheory.Measure.map f (ν.withDensity (μ.rnDeriv ν)) =
(MeasureTheory.Measure.map f ν).withDensity
((MeasureTheory.Measure.map f μ).rnDeriv (MeasureTheory.Measure.map f ν)) |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.isInvalidContinuationByte_getElem_utf8EncodeChar_one_of_utf8Size_eq_two | Init.Data.String.Decode | ∀ {c : Char} (hc : c.utf8Size = 2),
ByteArray.utf8DecodeChar?.isInvalidContinuationByte (String.utf8EncodeChar c)[1] = false |
Subgroup.IsArithmetic.conj | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ (𝒢 : Subgroup (GL (Fin 2) ℝ)) [𝒢.IsArithmetic] (g : GL (Fin 2) ℚ),
(ConjAct.toConjAct ((Matrix.GeneralLinearGroup.map (Rat.castHom ℝ)) g) • 𝒢).IsArithmetic |
CategoryTheory.Triangulated.Octahedron.map._proof_5 | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {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] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] [inst_4 : CategoryTheory.Limits.HasZeroObject C]
[inst_5 : CategoryTheory.Preadditive C] [inst_6 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_7 : CategoryTheory.Pretriangulated C] {X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C} {u₁₂ : X₁ ⟶ X₂} {u₂₃ : X₂ ⟶ X₃} {u₁₃ : X₁ ⟶ X₃}
{comm : CategoryTheory.CategoryStruct.comp u₁₂ u₂₃ = u₁₃} {v₁₂ : X₂ ⟶ Z₁₂}
{w₁₂ : Z₁₂ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁}
{h₁₂ : CategoryTheory.Pretriangulated.Triangle.mk u₁₂ v₁₂ w₁₂ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}
{v₂₃ : X₃ ⟶ Z₂₃} {w₂₃ : Z₂₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₂}
{h₂₃ : CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}
{v₁₃ : X₃ ⟶ Z₁₃} {w₁₃ : Z₁₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁}
{h₁₃ : CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles}
(h : CategoryTheory.Triangulated.Octahedron comm h₁₂ h₂₃ h₁₃) (F : CategoryTheory.Functor C D)
[inst_8 : F.CommShift ℤ],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃).mor₃)
((CategoryTheory.Functor.commShiftIso F 1).hom.app
(CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃).obj₁))
((CategoryTheory.shiftFunctor D 1).map (F.map (CategoryTheory.Pretriangulated.Triangle.mk u₁₂ v₁₂ w₁₂).mor₁)) =
CategoryTheory.CategoryStruct.comp (F.map h.m₃)
(CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃).mor₃)
((CategoryTheory.Functor.commShiftIso F 1).hom.app
(CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃).obj₁)) |
Subalgebra.toSubmodule | Mathlib.Algebra.Algebra.Subalgebra.Basic | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → Subalgebra R A ↪o Submodule R A |
UInt64.ofNat | Init.Data.UInt.BasicAux | ℕ → UInt64 |
GenContFract.first_cont_eq | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} {g : GenContFract K} [inst : DivisionRing K] {gp : GenContFract.Pair K},
g.s.get? 0 = some gp → g.conts 1 = { a := gp.b * g.h + gp.a, b := gp.b } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.