name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
UniqueMul.of_mulHom_image | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Mul G] [inst_1 : Mul H] {A B : Finset G} {a0 b0 : G} [inst_2 : DecidableEq H]
(f : G →ₙ* H),
(∀ ⦃a b c d : G⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d) →
UniqueMul (Finset.image (⇑f) A) (Finset.image (⇑f) B) (f a0) (f b0) → UniqueMul A B a0 b0 | true |
Std.Tactic.BVDecide.Frontend.Normalize.BitVec.add_left_inj | Std.Tactic.BVDecide.Normalize.Equal | ∀ {w : ℕ} (a b c : BitVec w), (a + c == b + c) = (a == b) | true |
Std.DHashMap.Const.getKeyD_insertMany_list_of_mem | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {l : List (α × β)} {k k' fallback : α},
(k == k') = true →
List.Pairwise (fun a b => (a.1 == b.1) = false) l →
k ∈ List.map Prod.fst l → (Std.DHashMap.Const.insertMany m l).getKeyD k' fallback = k | true |
List.toList_mkSlice_roi | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {lo : ℕ}, Std.Slice.toList (Std.Roi.Sliceable.mkSlice xs lo<...*) = List.drop (lo + 1) xs | true |
_private.Mathlib.Control.Monad.Cont.0.ExceptT.run_bind.match_1.splitter | Mathlib.Control.Monad.Cont | {ε α : Type u_1} →
(motive : Except ε α → Sort u_2) →
(x : Except ε α) → ((x : α) → motive (Except.ok x)) → ((e : ε) → motive (Except.error e)) → motive x | true |
Subgroup.widthInfty | Mathlib.NumberTheory.ModularForms.Cusps | Subgroup (GL (Fin 2) ℝ) → ℝ | true |
Lean.Elab.WF.mkWfParam | Lean.Elab.PreDefinition.WF.Preprocess | Lean.Expr → Lean.MetaM Lean.Expr | true |
Char.minSurrogate | Batteries.Data.Char.Basic | ℕ | true |
FGAlgCat.uliftFunctor._proof_3 | Mathlib.Algebra.Category.CommAlgCat.FiniteType | ∀ (R : Type u_1) [inst : CommRing R] (A : FGAlgCat R), Algebra.FiniteType R ↑(CommAlgCat.of R (ULift.{u_3, u_2} ↑A.obj)) | false |
AddSubmonoid.LocalizationMap.map_comp_map | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N] {P : Type u_3}
[inst_2 : AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : ↥S), g ↑y ∈ T)
{Q : Type u_4} [inst_3 : AddCommMonoid Q] {k : T.LocalizationMap Q} {A : Type u_5} [inst_4 : AddCommMonoid A]
{U : AddSubmonoid A} {R : Type u_6} [inst_5 : AddCommMonoid R] (j : U.LocalizationMap R) {l : P →+ A}
(hl : ∀ (w : ↥T), l ↑w ∈ U), (k.map hl j).comp (f.map hy k) = f.map ⋯ j | true |
CategoryTheory.shiftFunctorZero_hom_app_shift | Mathlib.CategoryTheory.Shift.Basic | ∀ {C : Type u} {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddCommMonoid A]
[inst_2 : CategoryTheory.HasShift C A] {X : C} (n : A),
(CategoryTheory.shiftFunctorZero C A).hom.app ((CategoryTheory.shiftFunctor C n).obj X) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorComm C n 0).hom.app X)
((CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorZero C A).hom.app X)) | true |
Lean.Lsp.LeanDidOpenTextDocumentParams.toDidOpenTextDocumentParams | Lean.Data.Lsp.Extra | Lean.Lsp.LeanDidOpenTextDocumentParams → Lean.Lsp.DidOpenTextDocumentParams | true |
Finset.inl_mem_sumLift₂ | Mathlib.Data.Sum.Interval | ∀ {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6}
{f : α₁ → β₁ → Finset γ₁} {g : α₂ → β₂ → Finset γ₂} {a : α₁ ⊕ α₂} {b : β₁ ⊕ β₂} {c₁ : γ₁},
Sum.inl c₁ ∈ Finset.sumLift₂ f g a b ↔ ∃ a₁ b₁, a = Sum.inl a₁ ∧ b = Sum.inl b₁ ∧ c₁ ∈ f a₁ b₁ | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.StructId.0.Lean.Meta.Grind.Arith.Linear.mkNatModuleInst? | Lean.Meta.Tactic.Grind.Arith.Linear.StructId | Lean.Level → Lean.Expr → Lean.Meta.Grind.GoalM (Option Lean.Expr) | true |
Set.subset_compl_iff_disjoint_right | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊆ tᶜ ↔ Disjoint s t | true |
GroupWithZero.div_eq_mul_inv | Mathlib.Algebra.GroupWithZero.Defs | ∀ {G₀ : Type u} [self : GroupWithZero G₀] (a b : G₀), a / b = a * b⁻¹ | true |
AlgebraicGeometry.Scheme.IsLocallyDirected.tAux._proof_2 | Mathlib.AlgebraicGeometry.Gluing | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AlgebraicGeometry.Scheme)
[inst_1 : ∀ {i j : J} (f : i ⟶ j), AlgebraicGeometry.IsOpenImmersion (F.map f)] (i j : J)
(k :
(AlgebraicGeometry.Scheme.Opens.iSupOpenCover fun k => AlgebraicGeometry.Scheme.Hom.opensRange (F.map k.snd.1)).I₀),
AlgebraicGeometry.IsOpenImmersion (F.map k.snd.1) | false |
_private.Lean.Meta.Sym.Apply.0.Lean.Meta.Sym.BackwardRule.apply'.match_1 | Lean.Meta.Sym.Apply | (motive : Lean.Meta.Sym.ApplyResult → Sort u_1) →
(__discr : Lean.Meta.Sym.ApplyResult) →
((mvarIds : List Lean.MVarId) → motive (Lean.Meta.Sym.ApplyResult.goals mvarIds)) →
((x : Lean.Meta.Sym.ApplyResult) → motive x) → motive __discr | false |
_private.Lean.Meta.FunInfo.0.Lean.Meta.FunInfoEnvCacheKey._sizeOf_inst | Lean.Meta.FunInfo | SizeOf Lean.Meta.FunInfoEnvCacheKey✝ | false |
complEDS.eq_1 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R) (k n : ℤ), complEDS b c d k n = ↑n.sign * complEDS' b c d k n.natAbs | true |
FrameHom.copy_eq | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice α] [inst_1 : CompleteLattice β] (f : FrameHom α β) (f' : α → β)
(h : f' = ⇑f), f.copy f' h = f | true |
ONote.zero | Mathlib.SetTheory.Ordinal.Notation | ONote | true |
_private.Mathlib.Topology.UniformSpace.AbstractCompletion.0.AbstractCompletion.termι'_2 | Mathlib.Topology.UniformSpace.AbstractCompletion | Lean.ParserDescr | true |
Preorder.noConfusionType | Mathlib.Order.Defs.PartialOrder | Sort u → {α : Type u_2} → Preorder α → {α' : Type u_2} → Preorder α' → Sort u | false |
Substring.Raw.ValidFor.startPos | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} {s : Substring.Raw}, Substring.Raw.ValidFor l m r s → s.startPos = { byteIdx := String.utf8Len l } | true |
CategoryTheory.Functor.precomposeWhiskerLeftMapCocone_hom_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] {F : CategoryTheory.Functor J C}
{H H' : CategoryTheory.Functor C D} (α : H ≅ H') (c : CategoryTheory.Limits.Cocone F),
(CategoryTheory.Functor.precomposeWhiskerLeftMapCocone α c).hom.hom = α.hom.app c.pt | true |
Topology.IsInducing.sumElim | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f : X → Z} {g : Y → Z},
Topology.IsInducing f →
Topology.IsInducing g →
Disjoint (closure (Set.range f)) (Set.range g) →
Disjoint (Set.range f) (closure (Set.range g)) → Topology.IsInducing (Sum.elim f g) | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_394 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
List.idxOfNth w [g (g a)] {g a, g (g a)}.card + 1 ≤ (List.filter (fun x => decide (x = w)) [g (g a)]).length →
List.idxOfNth w [g (g a)] {g a, g (g a)}.card < (List.findIdxs (fun x => decide (x = w)) [g (g a)]).length | false |
CategoryTheory.Endofunctor.Coalgebra.isoMk_hom_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
{V₀ V₁ : CategoryTheory.Endofunctor.Coalgebra F} (h : V₀.V ≅ V₁.V)
(w :
autoParam
(CategoryTheory.CategoryStruct.comp V₀.str (F.map h.hom) = CategoryTheory.CategoryStruct.comp h.hom V₁.str)
CategoryTheory.Endofunctor.Coalgebra.isoMk._auto_1),
(CategoryTheory.Endofunctor.Coalgebra.isoMk h w).hom.f = h.hom | true |
CategoryTheory.ShortComplex.HomologyData.exact_iff_i_p_zero | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.HomologyData),
S.Exact ↔ CategoryTheory.CategoryStruct.comp h.left.i h.right.p = 0 | true |
Std.Sat.AIG.instDecidableEqDecl.decEq._proof_3 | Std.Sat.AIG.Basic | ∀ {α : Type} (idx : α), ¬Std.Sat.AIG.Decl.false = Std.Sat.AIG.Decl.atom idx | false |
List.Ico.filter_le | Mathlib.Data.List.Intervals | ∀ (n m l : ℕ), List.filter (fun x => decide (l ≤ x)) (List.Ico n m) = List.Ico (max n l) m | true |
CategoryTheory.ChosenPullbacksAlong.mk | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Y X : C} →
{f : Y ⟶ X} →
(pullback : CategoryTheory.Functor (CategoryTheory.Over X) (CategoryTheory.Over Y)) →
(CategoryTheory.Over.map f ⊣ pullback) → CategoryTheory.ChosenPullbacksAlong f | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.offset_lt_rawEndPos_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | false |
Equiv.Perm.Basis.ofPermHom._proof_7 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} (a : g.Basis)
(σ τ : ↥(Equiv.Perm.OnCycleFactors.range_toPermHom' g)) (x : α),
a.ofPermHomFun (σ * τ)⁻¹ (a.ofPermHomFun (σ * τ) x) = x | false |
TopCat.Presheaf.algebra_section_stalk | Mathlib.Topology.Sheaves.CommRingCat | {X : TopCat} →
(F : TopCat.Presheaf CommRingCat X) →
{U : TopologicalSpace.Opens ↑X} → (x : ↥U) → Algebra ↑(F.obj (Opposite.op U)) ↑(F.stalk ↑x) | true |
Representation.IntertwiningMap.instAddCommMonoid | Mathlib.RepresentationTheory.Intertwining | {A : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommMonoid W] →
[inst_4 : Module A V] →
[inst_5 : Module A W] →
(ρ : Representation A G V) → (σ : Representation A G W) → AddCommMonoid (ρ.IntertwiningMap σ) | true |
Nat.eq_iff_prime_padicValNat_eq | Mathlib.Data.Nat.Factorization.Basic | ∀ (a b : ℕ), a ≠ 0 → b ≠ 0 → (a = b ↔ ∀ (p : ℕ), Nat.Prime p → padicValNat p a = padicValNat p b) | true |
AlgebraicGeometry.Scheme.Hom.QuasiFiniteAt.quasiFiniteAt | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {x : ↥X},
AlgebraicGeometry.Scheme.Hom.QuasiFiniteAt f x →
∀ {V : X.Opens} (hV : AlgebraicGeometry.IsAffineOpen V) {U : Y.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ (hVU : V ≤ (TopologicalSpace.Opens.map f.base).obj U) (hxV : x ∈ V.carrier),
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.appLE f U V hVU)).QuasiFiniteAt
(hV.primeIdealOf ⟨x, hxV⟩).asIdeal | true |
Continuous.stronglyMeasurable | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [OpensMeasurableSpace α]
[inst_3 : TopologicalSpace β] [TopologicalSpace.PseudoMetrizableSpace β] [h : SecondCountableTopologyEither α β]
{f : α → β}, Continuous f → MeasureTheory.StronglyMeasurable f | true |
Std.ExtDHashMap.mem_filter | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{f : (a : α) → β a → Bool} {k : α}, k ∈ Std.ExtDHashMap.filter f m ↔ ∃ (h : k ∈ m), f k (m.get k h) = true | true |
Rat.mul_def | Init.Data.Rat.Lemmas | ∀ (a b : ℚ), a * b = Rat.normalize (a.num * b.num) (a.den * b.den) ⋯ | true |
Subtype.orderBot.eq_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} {p : α → Prop} [inst : LE α] [inst_1 : OrderBot α] (hbot : p ⊥),
Subtype.orderBot hbot = { bot := ⟨⊥, hbot⟩, bot_le := ⋯ } | true |
_private.Mathlib.Topology.NhdsWithin.0.eventually_mem_of_tendsto_nhdsWithin._simp_1_3 | Mathlib.Topology.NhdsWithin | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
MvPFunctor.liftP_iff | Mathlib.Data.PFunctor.Multivariate.Basic | ∀ {n : ℕ} {P : MvPFunctor.{u} n} {α : TypeVec.{u} n} (p : ⦃i : Fin2 n⦄ → α i → Prop) (x : ↑P α),
MvFunctor.LiftP p x ↔ ∃ a f, x = ⟨a, f⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), p (f i j) | true |
AlgebraicGeometry.continuousMapPresheafEquivOfTotallyDisconnectedSpace._proof_2 | Mathlib.AlgebraicGeometry.Sites.ConstantSheaf | ∀ (T : Type u_2) [inst : TopologicalSpace T] [inst_1 : TotallyDisconnectedSpace T] (U : AlgebraicGeometry.Scheme)
(f : C(ConnectedComponents ↥U, T)),
(fun f => { toFun := ⋯.connectedComponentsLift, continuous_toFun := ⋯ })
((fun f => f.comp { toFun := ConnectedComponents.mk, continuous_toFun := ⋯ }) f) =
f | false |
Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Type | true |
AlgebraicTopology.AlternatingFaceMapComplex.d_squared | Mathlib.AlgebraicTopology.AlternatingFaceMapComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C) (n : ℕ),
CategoryTheory.CategoryStruct.comp (AlgebraicTopology.AlternatingFaceMapComplex.objD X (n + 1))
(AlgebraicTopology.AlternatingFaceMapComplex.objD X n) =
0 | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Proof.0.Lean.Meta.Grind.Arith.Linear.RingIneqCnstr.toExprProof.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | (motive : Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof → Sort u_1) →
(x : Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof) →
((e : Lean.Expr) →
(lhs rhs : Lean.Grind.CommRing.Expr) →
motive (Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof.core e lhs rhs)) →
((e : Lean.Expr) →
(lhs rhs : Lean.Grind.CommRing.Expr) →
motive (Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof.notCore e lhs rhs)) →
((c : Lean.Meta.Grind.Arith.Linear.RingIneqCnstr) →
(val : ℤ) →
(x n : Lean.Grind.Linarith.Var) →
motive (Lean.Meta.Grind.Arith.Linear.RingIneqCnstrProof.cancelDen c val x n)) →
motive x | false |
PrimeSpectrum.isHomeomorph_comap_tensorProductMap_of_isPurelyInseparable | Mathlib.RingTheory.Spectrum.Prime.Homeomorph | ∀ (K : Type u_2) (R : Type u_3) (S : Type u_4) [inst : Field K] [inst_1 : CommRing R] [inst_2 : CommRing S]
[inst_3 : Algebra R K] [inst_4 : Algebra R S] (L : Type u_5) [inst_5 : Field L] [inst_6 : Algebra R L]
[inst_7 : Algebra K L] [inst_8 : IsScalarTower R K L] [IsPurelyInseparable K L],
IsHomeomorph (PrimeSpectrum.comap (Algebra.TensorProduct.map (Algebra.ofId K L) (AlgHom.id R S)).toRingHom) | true |
Nat.mod_two_ne_zero | Init.Data.Nat.Lemmas | ∀ {n : ℕ}, n % 2 ≠ 0 ↔ n % 2 = 1 | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Constructions.0.NNReal.nndist_eq._simp_1_3 | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] {a b c : G},
(|a - b| ≤ c) = (a - b ≤ c ∧ b - a ≤ c) | false |
Zsqrtd.im | Mathlib.NumberTheory.Zsqrtd.Basic | {d : ℤ} → ℤ√d → ℤ | true |
SimpleGraph.reachable_iff_reflTransGen | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} (u v : V), G.Reachable u v ↔ Relation.ReflTransGen G.Adj u v | true |
Int16.ofInt_eq_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, Int16.ofInt ↑n = Int16.ofNat n | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.bestLabelForDecl?.visitNamespaces | Lean.Server.Completion.CompletionCollectors | (Lean.Name → StateT (Option Lean.Name) Lean.Server.Completion.M✝ Unit) →
Lean.Name → StateT (Option Lean.Name) Lean.Server.Completion.M✝¹ Unit | true |
PartialEquiv.ofSet_symm | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} (s : Set α), (PartialEquiv.ofSet s).symm = PartialEquiv.ofSet s | true |
SlashInvariantForm.instInhabited | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | {Γ : Subgroup (GL (Fin 2) ℝ)} → {k : ℤ} → Inhabited (SlashInvariantForm Γ k) | true |
_private.Mathlib.Algebra.Polynomial.Bivariate.0.Polynomial.Bivariate.swap_monomial_monomial._simp_1_1 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, (Polynomial.monomial n) a = Polynomial.C a * Polynomial.X ^ n | false |
Ordinal.termω₁ | Mathlib.SetTheory.Cardinal.Aleph | Lean.ParserDescr | true |
_private.Mathlib.Data.Int.Bitwise.0.Int.bitwise.match_1.eq_4 | Mathlib.Data.Int.Bitwise | ∀ (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 : (m n : ℕ) → motive (Int.negSucc m) (Int.ofNat n))
(h_4 : (m n : ℕ) → motive (Int.negSucc m) (Int.negSucc n)),
(match Int.negSucc m, Int.negSucc n with
| Int.ofNat m, Int.ofNat n => h_1 m n
| Int.ofNat m, Int.negSucc n => h_2 m n
| Int.negSucc m, Int.ofNat n => h_3 m n
| Int.negSucc m, Int.negSucc n => h_4 m n) =
h_4 m n | true |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Defs.0.BigOperators.FinsetResult.finset.noConfusion | Mathlib.Algebra.BigOperators.Group.Finset.Defs | {P : Sort u} →
{s s' : Lean.Term} → BigOperators.FinsetResult.finset✝ s = BigOperators.FinsetResult.finset✝¹ s' → (s = s' → P) → P | false |
Fin.reverseInduction.go.match_1 | Init.Data.Fin.Lemmas | {n : ℕ} →
{motive : Fin (n + 1) → Sort u_2} →
(i : Fin (n + 1)) →
(motive_1 : (j : ℕ) → (h : j < n + 1) → ↑i ≤ j → motive ⟨j, h⟩ → ¬↑i = j → Sort u_1) →
(j : ℕ) →
(h : j < n + 1) →
(h2 : ↑i ≤ j) →
(x : motive ⟨j, h⟩) →
(hi : ¬↑i = j) →
((h : 0 < n + 1) → (h2 : ↑i ≤ 0) → (x : motive ⟨0, h⟩) → (hi : ¬↑i = 0) → motive_1 0 h h2 x hi) →
((j : ℕ) →
(h : j + 1 < n + 1) →
(h2 : ↑i ≤ j + 1) →
(x : motive ⟨j + 1, h⟩) → (hi : ¬↑i = j + 1) → motive_1 j.succ h h2 x hi) →
motive_1 j h h2 x hi | false |
Std.DTreeMap.Internal.Impl.Const.getKey_alter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
[Inhabited α] (h : t.WF) {k k' : α} {f : Option β → Option β}
{hc : k' ∈ Std.DTreeMap.Internal.Impl.Const.alter! k f t},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).getKey k' hc =
if heq : compare k k' = Ordering.eq then k else t.getKey k' ⋯ | true |
TopologicalSpace.OpenNhdsOf.instSetLike | Mathlib.Topology.Sets.Opens | {α : Type u_2} → [inst : TopologicalSpace α] → {x : α} → SetLike (TopologicalSpace.OpenNhdsOf x) α | true |
Std.DHashMap.Internal.Raw₀.erase_emptyWithCapacity | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {k : α} {c : ℕ},
(Std.DHashMap.Internal.Raw₀.emptyWithCapacity c).erase k = Std.DHashMap.Internal.Raw₀.emptyWithCapacity c | true |
genericPoints.isGenericPoint | Mathlib.Topology.Sober | ∀ {α : Type u_1} [inst : TopologicalSpace α] (x : ↑(genericPoints α)), IsGenericPoint ↑x ↑(genericPoints.component x) | true |
inv_inv_div_inv | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), (a⁻¹ / b⁻¹)⁻¹ = a / b | true |
IsLocalizedModule.mk'_sub_mk' | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_6} {M' : Type u_7} [inst_1 : AddCommGroup M]
[inst_2 : SubtractionCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[inst_5 : IsLocalizedModule S f] (m₁ m₂ : M) (s₁ s₂ : ↥S),
IsLocalizedModule.mk' f m₁ s₁ - IsLocalizedModule.mk' f m₂ s₂ = IsLocalizedModule.mk' f (s₂ • m₁ - s₁ • m₂) (s₁ * s₂) | true |
ValuationSubring.ext_iff | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] {A B : ValuationSubring K}, A = B ↔ ∀ (x : K), x ∈ A ↔ x ∈ B | true |
MvPowerSeries.rescale_one | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_9} [inst : CommSemiring R], MvPowerSeries.rescale 1 = RingHom.id (MvPowerSeries σ R) | true |
WithLp.sndₗ_apply | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (α : Type u_2) (β : Type u_3) [inst : Semiring 𝕜] [inst_1 : AddCommGroup α]
[inst_2 : AddCommGroup β] [inst_3 : Module 𝕜 α] [inst_4 : Module 𝕜 β] (x : WithLp p (α × β)),
(WithLp.sndₗ p 𝕜 α β) x = x.snd | true |
AddSubmonoid.recOn | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} →
[inst : AddZeroClass M] →
{motive : AddSubmonoid M → Sort u} →
(t : AddSubmonoid M) →
((toAddSubsemigroup : AddSubsemigroup M) →
(zero_mem' : 0 ∈ toAddSubsemigroup.carrier) →
motive { toAddSubsemigroup := toAddSubsemigroup, zero_mem' := zero_mem' }) →
motive t | false |
CategoryTheory.FreeMonoidalCategory.HomEquiv.tensor | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u} {W X Y Z : CategoryTheory.FreeMonoidalCategory C} {f f' : W.Hom X} {g g' : Y.Hom Z},
CategoryTheory.FreeMonoidalCategory.HomEquiv f f' →
CategoryTheory.FreeMonoidalCategory.HomEquiv g g' →
CategoryTheory.FreeMonoidalCategory.HomEquiv (f.tensor g) (f'.tensor g') | true |
Affine._aux_Mathlib_LinearAlgebra_AffineSpace_Defs___macroRules_Affine_termAffineSpace_1 | Mathlib.LinearAlgebra.AffineSpace.Defs | Lean.Macro | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.withLams | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | List Lean.FVarId →
Lean.Meta.RefinedDiscrTree.Key → StateT Lean.Meta.RefinedDiscrTree.LazyEntry Lean.MetaM Lean.Meta.RefinedDiscrTree.Key | true |
Ordinal.cof_iSup_le_lift | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {ι : Type u} {f : ι → Ordinal.{max u v}},
(∀ (i : ι), f i < iSup f) → (iSup f).cof ≤ Cardinal.lift.{v, u} (Cardinal.mk ι) | true |
_private.Init.Data.Nat.Basic.0.Nat.succ_pred_eq_of_ne_zero.match_1_1 | Init.Data.Nat.Basic | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0), (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 | false |
Std.IterM.Partial.find? | Init.Data.Iterators.Consumers.Monadic.Loop | {α β : Type w} →
{m : Type w → Type w'} →
[Monad m] →
[inst : Std.Iterator α m β] → [Std.IteratorLoop α m m] → Std.IterM.Partial m β → (β → Bool) → m (Option β) | true |
FundamentalGroupoidFunctor.homotopicMapsNatIso._proof_3 | Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f g : C(X, Y)}
(H : f.Homotopy g) ⦃X_1 Y_1 : FundamentalGroupoid X⦄ (f_1 : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp ((FundamentalGroupoid.map f).map f_1) ⟦H.evalAt Y_1.as⟧ =
CategoryTheory.CategoryStruct.comp ⟦H.evalAt X_1.as⟧ ((FundamentalGroupoid.map g).map f_1) | false |
Filter.instInvolutiveNeg._proof_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : InvolutiveNeg α] (f : Filter α), Filter.map (Neg.neg ∘ Neg.neg) f = f | false |
MulEquiv.toFun_eq_coe | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Mul M] [inst_1 : Mul N] (f : M ≃* N), f.toFun = ⇑f | true |
Lean.Meta.Sym.ProofInstInfo.argsInfo | Lean.Meta.Sym.SymM | Lean.Meta.Sym.ProofInstInfo → Array Lean.Meta.Sym.ProofInstArgInfo | true |
USize.ofFin_or | Init.Data.UInt.Bitwise | ∀ (a b : Fin USize.size), USize.ofFin (a ||| b) = USize.ofFin a ||| USize.ofFin b | true |
Lean.Order.bot | Init.Internal.Order.Basic | {α : Sort u} → [Lean.Order.CCPO α] → α | true |
Algebra.intNormAux._proof_3 | 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] [IsScalarTower A B L] [IsIntegralClosure B A L]
(s : B), IsIntegral A ((Algebra.norm K) ((algebraMap B L) s)) | false |
CategoryTheory.MorphismProperty.Comma.mapLeftIso._proof_2 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} A] {B : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} T]
(R : CategoryTheory.Functor B T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : CategoryTheory.MorphismProperty B} {L₁ L₂ : CategoryTheory.Functor A T} [P.RespectsIso] (e : L₁ ≅ L₂)
(X : CategoryTheory.MorphismProperty.Comma L₁ R P Q W),
P (CategoryTheory.CategoryStruct.comp (e.inv.app X.left) X.hom) | false |
ValuativeRel.ofValuation._proof_5 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {S : Type u_2} {Γ : Type u_1} [inst : CommRing S] [inst_1 : LinearOrderedCommGroupWithZero Γ] (v : Valuation S Γ)
{z y x : S}, v x ≤ v y → v y ≤ v z → v x ≤ v z | false |
CategoryTheory.HasWeakSheafify | Mathlib.CategoryTheory.Sites.Sheafification | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
CategoryTheory.GrothendieckTopology C → (A : Type u₂) → [CategoryTheory.Category.{v₂, u₂} A] → Prop | true |
PadicInt.toZModHom | Mathlib.NumberTheory.Padics.RingHoms | {p : ℕ} →
[hp_prime : Fact (Nat.Prime p)] →
(v : ℕ) →
(f : ℤ_[p] → ℕ) →
(∀ (x : ℤ_[p]), x - ↑(f x) ∈ Ideal.span {↑v}) →
(∀ (x : ℤ_[p]) (a b : ℕ), x - ↑a ∈ Ideal.span {↑v} → x - ↑b ∈ Ideal.span {↑v} → ↑a = ↑b) → ℤ_[p] →+* ZMod v | true |
_private.Init.Data.UInt.Bitwise.0.UInt16.shiftLeft_add_of_toNat_lt._proof_1_2 | Init.Data.UInt.Bitwise | ∀ {b c : UInt16}, b.toNat + c.toNat < 16 → ¬b.toNat < 16 → False | false |
CategoryTheory.Functor.isPointwiseRightKanExtensionOfHasPointwiseLeftDerivedFunctor | Mathlib.CategoryTheory.Functor.Derived.PointwiseLeftDerived | {C : Type u₁} →
{D : Type u₂} →
{H : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} H] →
(F' : CategoryTheory.Functor D H) →
{F : CategoryTheory.Functor C H} →
{L : CategoryTheory.Functor C D} →
(α : L.comp F' ⟶ F) →
(W : CategoryTheory.MorphismProperty C) →
[F.HasPointwiseLeftDerivedFunctor W] →
[inst_4 : L.IsLocalization W] →
[F'.IsLeftDerivedFunctor α W] →
(CategoryTheory.Functor.RightExtension.mk F' α).IsPointwiseRightKanExtension | true |
_private.Lean.Elab.DocString.Builtin.0.Lean.Doc.NoInfo.toCtorIdx | Lean.Elab.DocString.Builtin | Lean.Doc.NoInfo✝ → ℕ | false |
_private.Mathlib.Order.CompleteLattice.SetLike.0.CompleteSublattice.mem_sSup._simp_1_1 | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {T : ↥L} {x : X}, (x ∈ T) = (x ∈ L.subtype T) | false |
SetRel.dom | Mathlib.Data.Rel | {α : Type u_1} → {β : Type u_2} → SetRel α β → Set α | true |
List.ofFn_inj' | Mathlib.Data.List.OfFn | ∀ {α : Type u} {m n : ℕ} {f : Fin m → α} {g : Fin n → α}, List.ofFn f = List.ofFn g ↔ ⟨m, f⟩ = ⟨n, g⟩ | true |
Pi.ofNat_def | Mathlib.Data.Nat.Cast.Basic | ∀ {α : Type u_1} {π : α → Type u_3} (n : ℕ) [inst : (i : α) → OfNat (π i) n], OfNat.ofNat n = fun x => OfNat.ofNat n | true |
Lean.Meta.Grind.SplitCandidateWithAnchor.mk | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.SplitInfo → ℕ → Bool → Lean.Expr → UInt64 → Lean.Meta.Grind.SplitCandidateWithAnchor | true |
Lean.Server.Test.Runner.Client.HighlightedSubexprInfo.ctorIdx | Lean.Server.Test.Runner | Lean.Server.Test.Runner.Client.HighlightedSubexprInfo → ℕ | false |
Function.HasUncurry.recOn | Mathlib.Logic.Function.Basic | {α : Type u_5} →
{β : Type u_6} →
{γ : Type u_7} →
{motive : Function.HasUncurry α β γ → Sort u} →
(t : Function.HasUncurry α β γ) → ((uncurry : α → β → γ) → motive { uncurry := uncurry }) → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.