module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Data.Quot | {
"line": 387,
"column": 2
} | {
"line": 387,
"column": 33
} | [
{
"pp": "α : Sort u_1\ns : Setoid α\nx : α\ny : Quotient s\n⊢ ⟦x⟧ = y ↔ x ≈ y.out",
"usedConstants": [
"Quotient.out",
"Quotient.mk",
"Quotient",
"HasEquiv.Equiv",
"instHasEquivOfSetoid",
"Iff.trans",
"Eq",
"Quotient.eq"
]
}
] | refine Iff.trans ?_ Quotient.eq | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Quot | {
"line": 392,
"column": 2
} | {
"line": 392,
"column": 33
} | [
{
"pp": "α : Sort u_1\ns : Setoid α\nx : Quotient s\ny : α\n⊢ x = ⟦y⟧ ↔ x.out ≈ y",
"usedConstants": [
"Quotient.out",
"Quotient.mk",
"Quotient",
"HasEquiv.Equiv",
"instHasEquivOfSetoid",
"Iff.trans",
"Eq",
"Quotient.eq"
]
}
] | refine Iff.trans ?_ Quotient.eq | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Algebra.Opposites | {
"line": 199,
"column": 28
} | {
"line": 199,
"column": 48
} | [
{
"pp": "α : Type u_1\ninst✝ : Add α\n⊢ IsLeftCancelAdd αᵐᵒᵖ ∧ IsRightCancelAdd αᵐᵒᵖ ↔ IsLeftCancelAdd α ∧ IsRightCancelAdd α",
"usedConstants": [
"Eq.mpr",
"IsRightCancelAdd",
"congrArg",
"MulOpposite",
"id",
"_private.Mathlib.Algebra.Opposites.0.MulOpposite.isCancelAdd_... | isLeftCancelAdd_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Logic.Function.Iterate | {
"line": 222,
"column": 39
} | {
"line": 222,
"column": 65
} | [
{
"pp": "α : Type u\nf : α → α\nm n : ℕ\na : α\nhf : Injective f\nha : f^[m] a = f^[n] a\nh : n ≤ m\n⊢ f^[m - n + ?m.30] a = f^[?m.30] a",
"usedConstants": [
"Eq.mpr",
"congrArg",
"HSub.hSub",
"id",
"instSubNat",
"Nat.iterate",
"instHAdd",
"instHSub",
"N... | rwa [Nat.sub_add_cancel h] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Logic.Function.Iterate | {
"line": 222,
"column": 39
} | {
"line": 222,
"column": 65
} | [
{
"pp": "α : Type u\nf : α → α\nm n : ℕ\na : α\nhf : Injective f\nha : f^[m] a = f^[n] a\nh : n ≤ m\n⊢ f^[m - n + ?m.30] a = f^[?m.30] a",
"usedConstants": [
"Eq.mpr",
"congrArg",
"HSub.hSub",
"id",
"instSubNat",
"Nat.iterate",
"instHAdd",
"instHSub",
"N... | rwa [Nat.sub_add_cancel h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Function.Iterate | {
"line": 222,
"column": 39
} | {
"line": 222,
"column": 65
} | [
{
"pp": "α : Type u\nf : α → α\nm n : ℕ\na : α\nhf : Injective f\nha : f^[m] a = f^[n] a\nh : n ≤ m\n⊢ f^[m - n + ?m.30] a = f^[?m.30] a",
"usedConstants": [
"Eq.mpr",
"congrArg",
"HSub.hSub",
"id",
"instSubNat",
"Nat.iterate",
"instHAdd",
"instHSub",
"N... | rwa [Nat.sub_add_cancel h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Action.Faithful | {
"line": 101,
"column": 8
} | {
"line": 101,
"column": 20
} | [
{
"pp": "case refine_1\nR : Type u_4\nA : Type u_5\ninst✝² : MulOneClass A\ninst✝¹ : SMul R A\ninst✝ : IsScalarTower R A A\nx✝ : FaithfulSMul R A\nr₁ r₂ : R\nhr : r₁ • 1 = r₂ • 1\nh : ∀ {m₁ m₂ : R}, (∀ (a : A), m₁ • a = m₂ • a) → m₁ = m₂\na : A\n⊢ r₁ • a = r₂ • a",
"usedConstants": [
"Eq.mpr",
"... | ← one_mul a, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Basic | {
"line": 89,
"column": 4
} | {
"line": 89,
"column": 41
} | [
{
"pp": "case refl\nC : ℕ → Sort u_1\nn m : ℕ\nnext : {k : ℕ} → C k → C (k + 1)\nHnext : ∀ (n : ℕ), Injective next\nx y : C n\nH : leRecOn ⋯ (fun {k} ↦ next) x = leRecOn ⋯ (fun {k} ↦ next) y\n⊢ x = y",
"usedConstants": [
"Nat.le_refl",
"congrArg",
"Eq.mp",
"Nat.leRecOn",
"Nat",... | rwa [leRecOn_self, leRecOn_self] at H | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Order.PropInstances | {
"line": 48,
"column": 14
} | {
"line": 48,
"column": 44
} | [
{
"pp": "p q : Prop\n⊢ p ≤ q ∨ q ≤ p",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"true_or",
"Prop.le",
"instInhabitedTrue",
"Classical.propDecidable",
"LE.le",
"dite",
"instNonemptyOfInhabited",
"forall_const._simp_1",
"congr"... | by by_cases h : q <;> simp [h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Monotone.Basic | {
"line": 453,
"column": 15
} | {
"line": 453,
"column": 30
} | [
{
"pp": "case a\nα : Type u\nβ : Type v\ninst✝¹ : LinearOrder α\ninst✝ : PartialOrder β\nf : α → β\na₁ a₂ : α\nh_anti : Antitone f\nh_fa : f a₁ = f a₂\ni : α\nh₁ : a₁ ≤ i\nh₂ : i ≤ a₂\n⊢ f a₂ ≤ f i",
"usedConstants": []
}
] | exact h_anti h₂ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.Disjoint | {
"line": 169,
"column": 2
} | {
"line": 172,
"column": 28
} | [
{
"pp": "α : Type u_1\ninst✝¹ : SemilatticeInf α\ninst✝ : OrderBot α\npr : α → Prop\nPinf : ∀ ⦃s t : α⦄, pr s → pr t → pr (s ⊓ t)\nhbot : pr ⊥\na b : Subtype pr\n⊢ Disjoint a b ↔ Disjoint ↑a ↑b",
"usedConstants": [
"Eq.mpr",
"Subtype.orderBot",
"congrArg",
"OrderBot.toBot",
"Pa... | letI : SemilatticeInf (Subtype pr) := Subtype.semilatticeInf Pinf
letI : OrderBot (Subtype pr) := Subtype.orderBot hbot
rw [disjoint_iff, disjoint_iff, ← Subtype.coe_inf Pinf, ← Subtype.coe_bot hbot]
exact Subtype.coe_inj.symm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Disjoint | {
"line": 169,
"column": 2
} | {
"line": 172,
"column": 28
} | [
{
"pp": "α : Type u_1\ninst✝¹ : SemilatticeInf α\ninst✝ : OrderBot α\npr : α → Prop\nPinf : ∀ ⦃s t : α⦄, pr s → pr t → pr (s ⊓ t)\nhbot : pr ⊥\na b : Subtype pr\n⊢ Disjoint a b ↔ Disjoint ↑a ↑b",
"usedConstants": [
"Eq.mpr",
"Subtype.orderBot",
"congrArg",
"OrderBot.toBot",
"Pa... | letI : SemilatticeInf (Subtype pr) := Subtype.semilatticeInf Pinf
letI : OrderBot (Subtype pr) := Subtype.orderBot hbot
rw [disjoint_iff, disjoint_iff, ← Subtype.coe_inf Pinf, ← Subtype.coe_bot hbot]
exact Subtype.coe_inj.symm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Basic | {
"line": 910,
"column": 2
} | {
"line": 910,
"column": 58
} | [
{
"pp": "α : Type u\ns : Set α\np : α → Prop\n⊢ {x | x ∈ s ∧ p x} = s ↔ ∀ (x : α), x ∈ s → p x",
"usedConstants": [
"_private.Mathlib.Data.Set.Basic.0.Set.sep_eq_self_iff_mem_true._simp_1_1",
"Eq.mpr",
"congrArg",
"Set.mem_sep_iff._simp_1",
"setOf",
"Membership.mem",
... | simp_rw [Set.ext_iff, mem_sep_iff, and_iff_left_iff_imp] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Data.Set.Basic | {
"line": 910,
"column": 2
} | {
"line": 910,
"column": 58
} | [
{
"pp": "α : Type u\ns : Set α\np : α → Prop\n⊢ {x | x ∈ s ∧ p x} = s ↔ ∀ (x : α), x ∈ s → p x",
"usedConstants": [
"_private.Mathlib.Data.Set.Basic.0.Set.sep_eq_self_iff_mem_true._simp_1_1",
"Eq.mpr",
"congrArg",
"Set.mem_sep_iff._simp_1",
"setOf",
"Membership.mem",
... | simp_rw [Set.ext_iff, mem_sep_iff, and_iff_left_iff_imp] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Basic | {
"line": 910,
"column": 2
} | {
"line": 910,
"column": 58
} | [
{
"pp": "α : Type u\ns : Set α\np : α → Prop\n⊢ {x | x ∈ s ∧ p x} = s ↔ ∀ (x : α), x ∈ s → p x",
"usedConstants": [
"_private.Mathlib.Data.Set.Basic.0.Set.sep_eq_self_iff_mem_true._simp_1_1",
"Eq.mpr",
"congrArg",
"Set.mem_sep_iff._simp_1",
"setOf",
"Membership.mem",
... | simp_rw [Set.ext_iff, mem_sep_iff, and_iff_left_iff_imp] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Lattice | {
"line": 265,
"column": 62
} | {
"line": 266,
"column": 39
} | [
{
"pp": "α : Type u\ninst✝ : SemilatticeSup α\na b c : α\n⊢ a ⊔ b ⊔ c = a ⊔ c ⊔ b",
"usedConstants": [
"Eq.mpr",
"congrArg",
"SemilatticeSup.toMax",
"id",
"sup_assoc",
"sup_comm",
"Max.max",
"Eq.refl",
"Eq"
]
}
] | by
rw [sup_assoc, sup_assoc, sup_comm b] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Set.Subsingleton | {
"line": 274,
"column": 2
} | {
"line": 274,
"column": 46
} | [
{
"pp": "α : Type u\ns : Set α\n⊢ Nontrivial ↑s ↔ s.Nontrivial",
"usedConstants": [
"Nontrivial",
"Iff.of_eq",
"congrArg",
"Set.mem_univ._simp_1",
"Set.univ",
"Membership.mem",
"Exists",
"Set.Elem",
"Subtype",
"Ne",
"Subtype.exists._simp_1",
... | simp [← nontrivial_univ_iff, Set.Nontrivial] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Set.Subsingleton | {
"line": 274,
"column": 2
} | {
"line": 274,
"column": 46
} | [
{
"pp": "α : Type u\ns : Set α\n⊢ Nontrivial ↑s ↔ s.Nontrivial",
"usedConstants": [
"Nontrivial",
"Iff.of_eq",
"congrArg",
"Set.mem_univ._simp_1",
"Set.univ",
"Membership.mem",
"Exists",
"Set.Elem",
"Subtype",
"Ne",
"Subtype.exists._simp_1",
... | simp [← nontrivial_univ_iff, Set.Nontrivial] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Subsingleton | {
"line": 274,
"column": 2
} | {
"line": 274,
"column": 46
} | [
{
"pp": "α : Type u\ns : Set α\n⊢ Nontrivial ↑s ↔ s.Nontrivial",
"usedConstants": [
"Nontrivial",
"Iff.of_eq",
"congrArg",
"Set.mem_univ._simp_1",
"Set.univ",
"Membership.mem",
"Exists",
"Set.Elem",
"Subtype",
"Ne",
"Subtype.exists._simp_1",
... | simp [← nontrivial_univ_iff, Set.Nontrivial] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Lattice | {
"line": 776,
"column": 2
} | {
"line": 776,
"column": 20
} | [
{
"pp": "α : Type u\nβ : Type v\nf : α → β\ns : Set α\nx y : α\ninst✝¹ : LinearOrder α\ninst✝ : SemilatticeSup β\nhf : MonotoneOn f s\nhx : x ∈ s\nhy : y ∈ s\n⊢ f (max x y) = f x ⊔ f y",
"usedConstants": [
"le_total"
]
}
] | cases le_total x y | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Order.Lattice | {
"line": 846,
"column": 2
} | {
"line": 846,
"column": 20
} | [
{
"pp": "α : Type u\nβ : Type v\nf : α → β\ns : Set α\nx y : α\ninst✝¹ : LinearOrder α\ninst✝ : SemilatticeInf β\nhf : AntitoneOn f s\nhx : x ∈ s\nhy : y ∈ s\n⊢ f (max x y) = f x ⊓ f y",
"usedConstants": [
"le_total"
]
}
] | cases le_total x y | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Order.BooleanAlgebra.Set | {
"line": 429,
"column": 65
} | {
"line": 430,
"column": 71
} | [
{
"pp": "α : Type u_1\ns : Set α\na : α\n⊢ insert a (s \\ {a}) = insert a s",
"usedConstants": [
"congrArg",
"Set.instUnion",
"Set.instSingletonSet",
"Insert.insert",
"SDiff.sdiff",
"Set.instInsert",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
... | by
simp [insert_eq, union_diff_self, -union_singleton, -singleton_union] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Logic.Equiv.Option | {
"line": 100,
"column": 6
} | {
"line": 101,
"column": 18
} | [
{
"pp": "case some.none\nα : Type u_1\nβ : Type u_2\ne : Option α ≃ Option β\nx val✝ : α\nh1 : e.symm (some (e.removeNone_aux x)) = some val✝\nh2 : e (some x) = none\n⊢ some (e.symm.removeNone_aux (e.removeNone_aux x)) = some x",
"usedConstants": [
"Equiv.removeNone_aux",
"False",
"Equiv.i... | · rw [removeNone_aux_none _ h2] at h1
simp at h1 | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Sigma.Basic | {
"line": 169,
"column": 2
} | {
"line": 169,
"column": 11
} | [
{
"pp": "α : Type u_1\nβ : α → Type u_4\nγ : (a : α) → β a → Type u_7\ninst✝¹ : DecidableEq α\ninst✝ : (a : α) → DecidableEq (β a)\nf : (i : (a : α) × β a) → γ i.fst i.snd\nia : α\nib : β ia\nx : γ ⟨ia, ib⟩.fst ⟨ia, ib⟩.snd\n⊢ curry (update f ⟨ia, ib⟩ x) = update (curry f) ⟨ia, ib⟩.fst (update (curry f ⟨ia, ib⟩... | ext ja jb | _private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.evalExt | Lean.Elab.Tactic.Ext.ext |
Mathlib.Data.Set.Image | {
"line": 424,
"column": 6
} | {
"line": 424,
"column": 25
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ns : Set α\nhs : s.Nonempty\nt : Set β\na : β\n⊢ s ⊆ (fun x ↦ a) ⁻¹' t ↔ a ∈ t",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Membership.mem",
"id",
"HasSubset.Subset",
"Iff",
"Set.preimage",
"propext",
"Set.image",
... | ← image_subset_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Set.Image | {
"line": 536,
"column": 4
} | {
"line": 536,
"column": 39
} | [
{
"pp": "case h.inl\nα : Type u_1\ns : Set α\nσ : Equiv.Perm α\nhs : {a | σ a ≠ a} ⊆ s\ni : α\nhi : σ i = i\nj : α\nhj : j ∈ s\nh : σ j = i\n⊢ i ∈ s",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"congrArg",
"Membership.mem",
"id",
"Equiv",
"Equiv.Perm",
... | rwa [σ.injective (hi.trans h.symm)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Data.Set.Image | {
"line": 601,
"column": 25
} | {
"line": 601,
"column": 44
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nf : α → β\ns : Set β\n⊢ univ ⊆ f ⁻¹' s ↔ range f ⊆ s",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Set.univ",
"id",
"HasSubset.Subset",
"Iff",
"Set.preimage",
"propext",
"Set.image",
"Set.image_subset_iff",
... | ← image_subset_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Set.Prod | {
"line": 908,
"column": 6
} | {
"line": 908,
"column": 49
} | [
{
"pp": "case h\nι : Type u_1\nι' : Type u_2\nα : ι → Type u_3\nf : ι' ≃ ι\ns : Set ι'\nt : (i : ι) → Set (α i)\n⊢ ∀ (x : (a : ι') → α (f a)), x ∈ ⇑(piCongrLeft α f) ⁻¹' (⇑f '' s).pi t ↔ x ∈ s.pi fun i ↦ t (f i)",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"congrArg",
"Membe... | ← (f.piCongrLeft α).symm.forall_congr_right | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Set.Function | {
"line": 1077,
"column": 44
} | {
"line": 1077,
"column": 68
} | [
{
"pp": "case refine_3\nα : Type u_1\nβ : Type u_2\ns s₁ : Set α\nt : Set β\nf : α → β\nt' : Set β\nh : BijOn f s t\nhss₁ : s ⊆ s₁\nhtt' : t ⊆ t'\nht' : SurjOn f s₁ t'\nr : Set α\nhrss : r ⊆ (s₁ ∩ f ⁻¹' t') \\ f ⁻¹' t\nhbij : BijOn f r ((f '' s₁ ∩ t') \\ t)\n⊢ InjOn f r ∧ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ r → f... | and_iff_right hbij.injOn | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Set.Image | {
"line": 982,
"column": 2
} | {
"line": 983,
"column": 94
} | [
{
"pp": "α : Type u_5\nβ : Type u_6\nγ : Type u_7\nγ' : Type u_8\nδ : Type u_9\nδ' : Type u_10\nh : β → α\nf : γ → β\nf₁ : γ' → α\nf₂ : γ → γ'\ng : δ → β\ng₁ : δ' → α\ng₂ : δ → δ'\nhf : h ∘ f = f₁ ∘ f₂\nhg : h ∘ g = g₁ ∘ g₂\nhfg : range f ∪ range g = univ\ns : Set β\n⊢ h '' s = f₁ '' f₂ '' f ⁻¹' s ∪ g₁ '' g₂ ''... | rw [← image_comp, ← image_comp, ← hf, ← hg, image_comp, image_comp, image_preimage_eq_inter_range,
image_preimage_eq_inter_range, ← image_union, ← inter_union_distrib_left, hfg, inter_univ] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Set.Image | {
"line": 982,
"column": 2
} | {
"line": 983,
"column": 94
} | [
{
"pp": "α : Type u_5\nβ : Type u_6\nγ : Type u_7\nγ' : Type u_8\nδ : Type u_9\nδ' : Type u_10\nh : β → α\nf : γ → β\nf₁ : γ' → α\nf₂ : γ → γ'\ng : δ → β\ng₁ : δ' → α\ng₂ : δ → δ'\nhf : h ∘ f = f₁ ∘ f₂\nhg : h ∘ g = g₁ ∘ g₂\nhfg : range f ∪ range g = univ\ns : Set β\n⊢ h '' s = f₁ '' f₂ '' f ⁻¹' s ∪ g₁ '' g₂ ''... | rw [← image_comp, ← image_comp, ← hf, ← hg, image_comp, image_comp, image_preimage_eq_inter_range,
image_preimage_eq_inter_range, ← image_union, ← inter_union_distrib_left, hfg, inter_univ] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Image | {
"line": 982,
"column": 2
} | {
"line": 983,
"column": 94
} | [
{
"pp": "α : Type u_5\nβ : Type u_6\nγ : Type u_7\nγ' : Type u_8\nδ : Type u_9\nδ' : Type u_10\nh : β → α\nf : γ → β\nf₁ : γ' → α\nf₂ : γ → γ'\ng : δ → β\ng₁ : δ' → α\ng₂ : δ → δ'\nhf : h ∘ f = f₁ ∘ f₂\nhg : h ∘ g = g₁ ∘ g₂\nhfg : range f ∪ range g = univ\ns : Set β\n⊢ h '' s = f₁ '' f₂ '' f ⁻¹' s ∪ g₁ '' g₂ ''... | rw [← image_comp, ← image_comp, ← hf, ← hg, image_comp, image_comp, image_preimage_eq_inter_range,
image_preimage_eq_inter_range, ← image_union, ← inter_union_distrib_left, hfg, inter_univ] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Torsion | {
"line": 49,
"column": 2
} | {
"line": 49,
"column": 67
} | [
{
"pp": "M : Type u_1\ninst✝¹ : Monoid M\ninst✝ : IsMulTorsionFree M\nn : ℕ\na : M\n⊢ a ^ n = 1 ↔ a = 1 ∨ n = 0",
"usedConstants": [
"MulOne.toOne",
"False",
"eq_false",
"Monoid.toMulOneClass",
"congrArg",
"Ne",
"instOfNatNat",
"pow_zero",
"Or.casesOn",
... | obtain rfl | hn := eq_or_ne n 0 <;> simp [pow_eq_one_iff_left, *] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Algebra.Group.Torsion | {
"line": 49,
"column": 2
} | {
"line": 49,
"column": 67
} | [
{
"pp": "M : Type u_1\ninst✝¹ : Monoid M\ninst✝ : IsMulTorsionFree M\nn : ℕ\na : M\n⊢ a ^ n = 1 ↔ a = 1 ∨ n = 0",
"usedConstants": [
"MulOne.toOne",
"False",
"eq_false",
"Monoid.toMulOneClass",
"congrArg",
"Ne",
"instOfNatNat",
"pow_zero",
"Or.casesOn",
... | obtain rfl | hn := eq_or_ne n 0 <;> simp [pow_eq_one_iff_left, *] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Torsion | {
"line": 49,
"column": 2
} | {
"line": 49,
"column": 67
} | [
{
"pp": "M : Type u_1\ninst✝¹ : Monoid M\ninst✝ : IsMulTorsionFree M\nn : ℕ\na : M\n⊢ a ^ n = 1 ↔ a = 1 ∨ n = 0",
"usedConstants": [
"MulOne.toOne",
"False",
"eq_false",
"Monoid.toMulOneClass",
"congrArg",
"Ne",
"instOfNatNat",
"pow_zero",
"Or.casesOn",
... | obtain rfl | hn := eq_or_ne n 0 <;> simp [pow_eq_one_iff_left, *] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Basic | {
"line": 490,
"column": 86
} | {
"line": 490,
"column": 95
} | [
{
"pp": "α : Type u_1\ninst✝ : DivisionMonoid α\na : α\nm n : ℤ\n⊢ a ^ (m * n) = (a ^ n) ^ m",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"zpow_mul'",
"DivInvMonoid.toZPow",
"id",
"Int",
"DivisionMonoid.toDivInvMonoid",
"Int.instMul",
"H... | zpow_mul' | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Basic | {
"line": 897,
"column": 4
} | {
"line": 897,
"column": 21
} | [
{
"pp": "case pred\nG : Type u_3\ninst✝ : Group G\ng : G\nP : G → Prop\nh_one : P 1\nh_mul : ∀ (a : G), P a → P (a * g)\nh_inv : ∀ (a : G), P a → P (a * g⁻¹)\nn : ℕ\nih : P (g ^ (-↑n))\n⊢ P (g ^ (-↑n - 1))",
"usedConstants": [
"Eq.mpr",
"zpow_sub_one",
"HMul.hMul",
"DivInvOneMonoid.t... | rw [zpow_sub_one] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.GroupWithZero.Basic | {
"line": 249,
"column": 19
} | {
"line": 249,
"column": 51
} | [
{
"pp": "case succ\nM₀ : Type u_1\nG₀ : Type u_2\ninst✝¹ : MonoidWithZero M₀\na✝ : M₀\nn✝ : ℕ\ninst✝ : NoZeroDivisors M₀\na : M₀\nx✝ : IsNilpotent a\nn : ℕ\nih : a ^ n = 0 → a = 0\nha : a ^ (n + 1) = 0\n⊢ a = 0",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"po... | rw [pow_succ, mul_eq_zero] at ha | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.GroupWithZero.Basic | {
"line": 476,
"column": 2
} | {
"line": 476,
"column": 22
} | [
{
"pp": "case neg\nG₀ : Type u_2\ninst✝ : GroupWithZero G₀\nn : ℤ\nh : ¬n = 0\n⊢ 0 ^ n = 0",
"usedConstants": [
"zero_zpow",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"GroupWithZero.toDivInvMonoid",
"congrArg",
"DivInvMonoid.toZPow",
"id",
"Int",
"Mono... | · rw [zero_zpow _ h] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.GroupWithZero.Hom | {
"line": 250,
"column": 37
} | {
"line": 251,
"column": 71
} | [
{
"pp": "M₀ : Type u_7\nN₀ : Type u_8\ninst✝⁵ : MulZeroOneClass M₀\ninst✝⁴ : MulZeroOneClass N₀\ninst✝³ : DecidablePred fun x ↦ x = 0\ninst✝² : Nontrivial M₀\ninst✝¹ : NoZeroDivisors M₀\ninst✝ : Nontrivial N₀\nx : M₀\n⊢ 1 x = 0 ↔ x = 0",
"usedConstants": [
"MulOne.toOne",
"False",
"NeZero.... | by
rcases eq_or_ne x 0 with rfl | hx <;> simp_all [one_apply_of_ne_zero] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.GroupWithZero.Hom | {
"line": 257,
"column": 37
} | {
"line": 258,
"column": 71
} | [
{
"pp": "M₀ : Type u_7\nN₀ : Type u_8\ninst✝⁵ : MulZeroOneClass M₀\ninst✝⁴ : MulZeroOneClass N₀\ninst✝³ : DecidablePred fun x ↦ x = 0\ninst✝² : Nontrivial M₀\ninst✝¹ : NoZeroDivisors M₀\ninst✝ : Nontrivial N₀\nx : M₀\n⊢ 1 x = 1 ↔ x ≠ 0",
"usedConstants": [
"MulOne.toOne",
"False",
"NeZero.... | by
rcases eq_or_ne x 0 with rfl | hx <;> simp_all [one_apply_of_ne_zero] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.End | {
"line": 573,
"column": 2
} | {
"line": 573,
"column": 36
} | [
{
"pp": "α : Type u_4\ninst✝ : DecidableEq α\ni j : α\nσ : Perm α\n⊢ swap i j * σ = σ ↔ i = j",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"CancelMonoid.toRightCancelMonoid",
"HMul.hMul",
"Equiv.Perm.instOne",
"mul_eq_right",
"Monoid.toMulOneClass",
"congrAr... | rw [mul_eq_right, swap_eq_one_iff] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.End | {
"line": 573,
"column": 2
} | {
"line": 573,
"column": 36
} | [
{
"pp": "α : Type u_4\ninst✝ : DecidableEq α\ni j : α\nσ : Perm α\n⊢ swap i j * σ = σ ↔ i = j",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"CancelMonoid.toRightCancelMonoid",
"HMul.hMul",
"Equiv.Perm.instOne",
"mul_eq_right",
"Monoid.toMulOneClass",
"congrAr... | rw [mul_eq_right, swap_eq_one_iff] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.End | {
"line": 573,
"column": 2
} | {
"line": 573,
"column": 36
} | [
{
"pp": "α : Type u_4\ninst✝ : DecidableEq α\ni j : α\nσ : Perm α\n⊢ swap i j * σ = σ ↔ i = j",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"CancelMonoid.toRightCancelMonoid",
"HMul.hMul",
"Equiv.Perm.instOne",
"mul_eq_right",
"Monoid.toMulOneClass",
"congrAr... | rw [mul_eq_right, swap_eq_one_iff] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.CharZero.Defs | {
"line": 57,
"column": 6
} | {
"line": 57,
"column": 70
} | [
{
"pp": "case succ.succ\nR : Type u_1\ninst✝ : AddGroupWithOne R\nH : ∀ (n : ℕ), ↑n = 0 → n = 0\nm : ℕ\nih : ∀ (n : ℕ), ↑m = ↑n → m = n\nn✝ : ℕ\nh : ↑(m + 1) = ↑(n✝ + 1)\n⊢ m + 1 = n✝ + 1",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"AddMonoid.toAddSemigroup",
"AddGroupWithOne.toA... | · simp only [Nat.cast_succ, add_right_cancel_iff] at h; rwa [ih] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Group.Even | {
"line": 145,
"column": 72
} | {
"line": 145,
"column": 96
} | [
{
"pp": "α : Type u_2\ninst✝ : Monoid α\nn : ℕ\nhn : Even n\n⊢ ∀ (a : α), IsSquare (a ^ n)",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"pow_add",
"Exists",
"MulOne.toMul",
"Even.exists_add_self",
"Monoid.toPow",
"instHAdd",
... | aesop (add simp pow_add) | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Algebra.Group.Even | {
"line": 145,
"column": 72
} | {
"line": 145,
"column": 96
} | [
{
"pp": "α : Type u_2\ninst✝ : Monoid α\nn : ℕ\nhn : Even n\n⊢ ∀ (a : α), IsSquare (a ^ n)",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"pow_add",
"Exists",
"MulOne.toMul",
"Even.exists_add_self",
"Monoid.toPow",
"instHAdd",
... | aesop (add simp pow_add) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Even | {
"line": 145,
"column": 72
} | {
"line": 145,
"column": 96
} | [
{
"pp": "α : Type u_2\ninst✝ : Monoid α\nn : ℕ\nhn : Even n\n⊢ ∀ (a : α), IsSquare (a ^ n)",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"pow_add",
"Exists",
"MulOne.toMul",
"Even.exists_add_self",
"Monoid.toPow",
"instHAdd",
... | aesop (add simp pow_add) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Ring.Basic | {
"line": 263,
"column": 22
} | {
"line": 263,
"column": 56
} | [
{
"pp": "R : Type u_1\ninst✝¹ : DivisionMonoid R\ninst✝ : HasDistribNeg R\na : R\n⊢ 1 / a * (1 / -1) = 1 / a * -1",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"InvOneClass.toOne",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
... | by rw [one_div_neg_one_eq_neg_one] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Ring.Basic | {
"line": 268,
"column": 54
} | {
"line": 268,
"column": 66
} | [
{
"pp": "R : Type u_1\ninst✝¹ : DivisionMonoid R\ninst✝ : HasDistribNeg R\na b : R\n⊢ b / -a = b * (-a)⁻¹",
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"id",
"MulOne.toMul",
"HDiv.hDiv",... | division_def | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.GroupWithZero.Units.Basic | {
"line": 486,
"column": 21
} | {
"line": 489,
"column": 34
} | [
{
"pp": "G₀ : Type u_3\ninst✝ : CommGroupWithZero G₀\na b c d : G₀\nhc : c ≠ 0\nhd : d ≠ 0\nh : a / b = c / d\n⊢ b ≠ 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"instHDiv",
"GroupWithZero.toDivInvMonoid",
"congrArg",
"Eq.mp",
"HDiv.hDiv",
"div_ne_zero",... | by
intro hb
rw [hb, div_zero] at h
exact div_ne_zero hc hd h.symm | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Cast.Commute | {
"line": 28,
"column": 32
} | {
"line": 28,
"column": 57
} | [
{
"pp": "case zero\nα : Type u_1\ninst✝ : NonAssocSemiring α\nx : α\n⊢ Commute 0 x",
"usedConstants": [
"Commute.zero_left",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"NonAssocSemiring.toNonUnitalNonAssocSemiring"
]
}
] | exact Commute.zero_left x | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Ring.Parity | {
"line": 155,
"column": 2
} | {
"line": 165,
"column": 70
} | [
{
"pp": "α : Type u_2\ninst✝¹ : Semiring α\na b : α\nn : ℕ\ninst✝ : IsCancelAdd α\nhn : Odd n\nhab : a + b = 0\n⊢ a ^ n + b ^ n = 0",
"usedConstants": [
"add_mul",
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.instMulZeroClass",
"Na... | obtain ⟨k, rfl⟩ := hn
induction k with | zero => simpa | succ k ih => ?_
have : a ^ 2 = b ^ 2 := add_right_cancel <|
calc
a ^ 2 + a * b = 0 := by rw [sq, ← mul_add, hab, mul_zero]
_ = b ^ 2 + a * b := by rw [sq, ← add_mul, add_comm, hab, zero_mul]
refine add_right_cancel (b := b ^ (2 * k + 1) * a ... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Ring.Parity | {
"line": 155,
"column": 2
} | {
"line": 165,
"column": 70
} | [
{
"pp": "α : Type u_2\ninst✝¹ : Semiring α\na b : α\nn : ℕ\ninst✝ : IsCancelAdd α\nhn : Odd n\nhab : a + b = 0\n⊢ a ^ n + b ^ n = 0",
"usedConstants": [
"add_mul",
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.instMulZeroClass",
"Na... | obtain ⟨k, rfl⟩ := hn
induction k with | zero => simpa | succ k ih => ?_
have : a ^ 2 = b ^ 2 := add_right_cancel <|
calc
a ^ 2 + a * b = 0 := by rw [sq, ← mul_add, hab, mul_zero]
_ = b ^ 2 + a * b := by rw [sq, ← add_mul, add_comm, hab, zero_mul]
refine add_right_cancel (b := b ^ (2 * k + 1) * a ... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.RelIso.Basic | {
"line": 421,
"column": 2
} | {
"line": 425,
"column": 38
} | [
{
"pp": "α : Type u_1\nx✝ : Setoid α\nr : α → α → Prop\nH : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂\n⊢ WellFounded (Quotient.lift₂ r H) ↔ WellFounded r",
"usedConstants": [
"Iff.mpr",
"acc_lift₂_iff",
"RelHomClass.wellFounded",
"WellFounded.apply",
"RelHom.in... | constructor
· exact RelHomClass.wellFounded (Quotient.mkRelHom H)
· refine fun wf => ⟨fun q => ?_⟩
obtain ⟨a, rfl⟩ := q.exists_rep
exact acc_lift₂_iff.2 (wf.apply a) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.RelIso.Basic | {
"line": 421,
"column": 2
} | {
"line": 425,
"column": 38
} | [
{
"pp": "α : Type u_1\nx✝ : Setoid α\nr : α → α → Prop\nH : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂\n⊢ WellFounded (Quotient.lift₂ r H) ↔ WellFounded r",
"usedConstants": [
"Iff.mpr",
"acc_lift₂_iff",
"RelHomClass.wellFounded",
"WellFounded.apply",
"RelHom.in... | constructor
· exact RelHomClass.wellFounded (Quotient.mkRelHom H)
· refine fun wf => ⟨fun q => ?_⟩
obtain ⟨a, rfl⟩ := q.exists_rep
exact acc_lift₂_iff.2 (wf.apply a) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 389,
"column": 2
} | {
"line": 389,
"column": 41
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : PartialOrder R\na b c d : R\ninst✝³ : ExistsAddOfLE R\ninst✝² : MulPosMono R\ninst✝¹ : AddLeftMono R\ninst✝ : AddLeftReflectLE R\nhba : b ≤ a\nhdc : d ≤ c\n⊢ a * d + b * c ≤ a * c + b * d",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrA... | rw [add_comm (a * d), add_comm (a * c)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 406,
"column": 2
} | {
"line": 406,
"column": 41
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : PartialOrder R\na b c d : R\ninst✝³ : AddLeftReflectLT R\ninst✝² : ExistsAddOfLE R\ninst✝¹ : MulPosStrictMono R\ninst✝ : AddLeftStrictMono R\nhba : b < a\nhdc : d < c\n⊢ a * d + b * c < a * c + b * d",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT... | rw [add_comm (a * d), add_comm (a * c)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 653,
"column": 4
} | {
"line": 653,
"column": 22
} | [
{
"pp": "case mp\nR : Type u\ninst✝⁶ : Semiring R\ninst✝⁵ : LinearOrder R\ninst✝⁴ : ExistsAddOfLE R\ninst✝³ : PosMulStrictMono R\ninst✝² : MulPosStrictMono R\ninst✝¹ : AddLeftStrictMono R\ninst✝ : AddLeftReflectLT R\nh : 0 < 0 * 0\n⊢ False",
"usedConstants": [
"Preorder.toLT",
"HMul.hMul",
... | rw [mul_zero] at h | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 707,
"column": 2
} | {
"line": 707,
"column": 24
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : LinearOrder R\ninst✝³ : ExistsAddOfLE R\ninst✝² : PosMulMono R\ninst✝¹ : AddLeftMono R\ninst✝ : NoZeroDivisors R\nr : R\n⊢ r ^ 2 = 0 ↔ r = 0",
"usedConstants": [
"isReduced_of_noZeroDivisors",
"Semiring.toMonoidWithZero",
"sq_eq_zero_iff"
... | · exact sq_eq_zero_iff | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | {
"line": 925,
"column": 52
} | {
"line": 925,
"column": 94
} | [
{
"pp": "G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : PosMulReflectLT G₀\na : G₀\nha : 0 < a\n⊢ a⁻¹ < 1 ↔ 1 < a",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"Preorder.toLT",
"GroupWithZero.toDivisionMonoid",
"InvOneClass.toOne",
"HMul.hM... | by simpa using inv_mul_lt_one₀ ha (b := 1) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | {
"line": 1424,
"column": 6
} | {
"line": 1424,
"column": 21
} | [
{
"pp": "G₀ : Type u_3\ninst✝² : CommGroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : PosMulReflectLT G₀\na b c : G₀\nhc : 0 < c\n⊢ a ≤ b / c ↔ c * a ≤ b",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"instHDiv",
"HMul.hMu... | le_div_iff₀ hc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Group.Unbundled.Abs | {
"line": 148,
"column": 79
} | {
"line": 150,
"column": 47
} | [
{
"pp": "α : Type u_1\ninst✝² : Lattice α\ninst✝¹ : CommGroup α\ninst✝ : MulLeftMono α\na b : α\n⊢ (a ⊔ b) ^ 2 = a * b * |b / a|ₘ",
"usedConstants": [
"sup_div_inf_eq_mabs_div",
"Eq.mpr",
"Semigroup.toMul",
"DivInvMonoid.toInv",
"Lattice.toSemilatticeSup",
"instHDiv",
... | by
rw [← inf_mul_sup a b, ← sup_div_inf_eq_mabs_div, div_eq_mul_inv, ← mul_assoc, mul_comm,
mul_assoc, ← pow_two, inv_mul_cancel_left] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Int.GCD | {
"line": 122,
"column": 2
} | {
"line": 123,
"column": 37
} | [
{
"pp": "x y : ℕ\n⊢ ↑(x.gcd y) = ↑x * x.gcdA y + ↑y * x.gcdB y",
"usedConstants": [
"Nat.gcd",
"HMul.hMul",
"Nat.xgcdAux",
"Monoid.toMulOneClass",
"congrArg",
"AddMonoid.toAddZeroClass",
"Eq.mp",
"_private.Mathlib.Data.Int.GCD.0.Nat.P",
"Nat.xgcd",
... | have := @xgcdAux_P x y x y 1 0 0 1 (by simp [P]) (by simp [P])
rwa [xgcdAux_val, xgcd_val] at this | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.GCD | {
"line": 122,
"column": 2
} | {
"line": 123,
"column": 37
} | [
{
"pp": "x y : ℕ\n⊢ ↑(x.gcd y) = ↑x * x.gcdA y + ↑y * x.gcdB y",
"usedConstants": [
"Nat.gcd",
"HMul.hMul",
"Nat.xgcdAux",
"Monoid.toMulOneClass",
"congrArg",
"AddMonoid.toAddZeroClass",
"Eq.mp",
"_private.Mathlib.Data.Int.GCD.0.Nat.P",
"Nat.xgcd",
... | have := @xgcdAux_P x y x y 1 0 0 1 (by simp [P]) (by simp [P])
rwa [xgcdAux_val, xgcd_val] at this | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.GCD | {
"line": 135,
"column": 78
} | {
"line": 135,
"column": 92
} | [
{
"pp": "case refine_2\nk n : ℕ\nhk : n.gcd k < k\nhk' : ↑k ≠ 0\nkey : n.gcd k = (↑n * n.gcdA k % ↑k).toNat\n⊢ ↑n % ↑k * (n.gcdA k % ↑k) % ↑k = ↑n * n.gcdA k % ↑k",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"id",
"instHMod",
"Int",
"Nat.cast",
"Int... | ← Int.mul_emod | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Regular.Basic | {
"line": 187,
"column": 83
} | {
"line": 188,
"column": 62
} | [
{
"pp": "R : Type u_1\ninst✝ : Monoid R\na : R\nn : ℕ\nrla : IsLeftRegular a\n⊢ IsLeftRegular (a ^ n)",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"MulOne.toMul",
"Function.Injective.iterate",
"Nat.iterate",
"Monoid.toPow",
"funext",
... | by
simp only [IsLeftRegular, ← mul_left_iterate, rla.iterate n] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Sub.Basic | {
"line": 140,
"column": 2
} | {
"line": 140,
"column": 90
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : AddCommMonoid α\ninst✝³ : LinearOrder α\ninst✝² : CanonicallyOrderedAdd α\ninst✝¹ : Sub α\ninst✝ : OrderedSub α\na b : α\nha : AddLECancellable a\nh₁ : b < a\nh₂ : 0 < b\nh : a - b = a\n⊢ False",
"usedConstants": [
"Eq.ge",
"AddMonoid.toAddSemigroup",
"AddMo... | exact h₂.not_ge (ha.add_le_iff_nonpos_left.1 <| add_le_of_le_tsub_left_of_le h₁.le h.ge) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Ring.Cast | {
"line": 102,
"column": 2
} | {
"line": 102,
"column": 45
} | [
{
"pp": "R : Type u_1\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nx : R\nn : ℤ\nhx : |x| ≤ 1\nhnx : 0 < n → 0 ≤ x + ↑n\nhnx' : n < 0 → x + ↑n ≤ 0\n⊢ 0 ≤ ↑n ∧ 0 ≤ x + ↑n ∨ ↑n ≤ 0 ∧ x + ↑n ≤ 0",
"usedConstants": [
"Int.instLinearOrder",
"Int",
"instOfNat",
... | rcases lt_trichotomy n 0 with (h | rfl | h) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Algebra.Order.GroupWithZero.Canonical | {
"line": 165,
"column": 6
} | {
"line": 165,
"column": 66
} | [
{
"pp": "case refine_3.inr\nα : Type u_1\ninst✝ : LinearOrderedCommGroupWithZero α\nx✝ : Nontrivial αˣ ∧ DenselyOrdered αˣ\nH₁ : Nontrivial αˣ\nH₂ : DenselyOrdered αˣ\ny x : αˣ\nh : ↑x < ↑y\nhx : 0 < ↑x\n⊢ ∃ a, ↑x < a ∧ a < ↑y",
"usedConstants": [
"Iff.mpr",
"Units.val",
"GroupWithZero.toM... | obtain ⟨z, hz, hz'⟩ := H₂.dense x y (Units.val_lt_val.mpr h) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.Order.GroupWithZero.Canonical | {
"line": 310,
"column": 32
} | {
"line": 316,
"column": 31
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝³ : Preorder α\ninst✝² : Preorder β\nx y : WithZero α\na b : α\ninst✝¹ : Mul α\ninst✝ : MulLeftMono α\n⊢ MulLeftMono (WithZero α)",
"usedConstants": [
"CovariantClass.mk",
"zero_le",
"Eq.mpr",
"WithZero.instIsBotZeroClass",
"HMul.hMul",... | by
refine ⟨fun a b c hbc => ?_⟩
induction a; · exact zero_le
induction b; · exact zero_le
rcases WithZero.coe_le_iff.1 hbc with ⟨c, rfl, hbc'⟩
rw [← coe_mul _ c, ← coe_mul, coe_le_coe]
exact mul_le_mul_right hbc' _ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Directed | {
"line": 56,
"column": 2
} | {
"line": 57,
"column": 62
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ns : Set α\n⊢ DirectedOn r s ↔ Directed r Subtype.val",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.Order.Directed.0.directedOn_iff_directed._simp_1_5",
"_private.Mathlib.Order.Directed.0.directedOn_iff_directed._simp_1_7",
"Iff.of_eq",
... | simp only [DirectedOn, Directed, Subtype.exists, exists_and_left, exists_prop, Subtype.forall]
exact forall₂_congr fun x _ => by simp [And.comm, and_assoc] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Directed | {
"line": 56,
"column": 2
} | {
"line": 57,
"column": 62
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ns : Set α\n⊢ DirectedOn r s ↔ Directed r Subtype.val",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.Order.Directed.0.directedOn_iff_directed._simp_1_5",
"_private.Mathlib.Order.Directed.0.directedOn_iff_directed._simp_1_7",
"Iff.of_eq",
... | simp only [DirectedOn, Directed, Subtype.exists, exists_and_left, exists_prop, Subtype.forall]
exact forall₂_congr fun x _ => by simp [And.comm, and_assoc] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Floor.Semiring | {
"line": 70,
"column": 8
} | {
"line": 70,
"column": 21
} | [
{
"pp": "R : Type u_1\ninst✝³ : Semiring R\ninst✝² : LinearOrder R\ninst✝¹ : FloorSemiring R\ninst✝ : IsStrictOrderedRing R\nn a : ℕ\n⊢ a ≤ ⌊↑n⌋₊ ↔ a ≤ n",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.t... | le_floor_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Semiring | {
"line": 370,
"column": 4
} | {
"line": 370,
"column": 31
} | [
{
"pp": "case inr\nR : Type u_1\ninst✝⁶ : Semiring R\ninst✝⁵ : LinearOrder R\ninst✝⁴ : FloorSemiring R\ninst✝³ : IsStrictOrderedRing R\ninst✝² : Sub R\ninst✝¹ : OrderedSub R\ninst✝ : ExistsAddOfLE R\na : R\nn : ℕ\nhna : ↑n ≤ a\n⊢ ⌈a - ↑n⌉₊ = ⌈a⌉₊ - n",
"usedConstants": [
"NonAssocSemiring.toAddCommMon... | refine eq_tsub_of_add_eq ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Algebra.Ring.Invertible | {
"line": 75,
"column": 52
} | {
"line": 76,
"column": 85
} | [
{
"pp": "R : Type u_1\ninst✝¹ : Ring R\ninst✝ : Invertible 2\n⊢ 2 * (1 - ⅟2) = 2 * ⅟2",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"Ring.toNonAssocRing",
"mul_sub",
"Monoid.toMulOneClass",
"AddGroupWithOne.toAddGroup"... | by
rw [mul_sub, mul_invOf_self, mul_one, ← one_add_one_eq_two, add_sub_cancel_right] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Bounds.Image | {
"line": 370,
"column": 4
} | {
"line": 370,
"column": 56
} | [
{
"pp": "case refine_1\nα : Type u_1\nβ : Type u_2\ninst✝¹ : Preorder α\ninst✝ : Preorder β\ns : Set (α × β)\np : α × β\nH : IsLUB s p\na : α\nha : a ∈ upperBounds (Prod.fst '' s)\n⊢ p.1 ≤ a",
"usedConstants": [
"Prod.instLE_mathlib",
"lowerBounds",
"Preorder.toLE",
"Membership.mem",... | suffices h : (a, p.2) ∈ upperBounds s from (H.2 h).1 | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSuffices__1 | Lean.Parser.Tactic.tacticSuffices_ |
Mathlib.Order.Interval.Set.Basic | {
"line": 580,
"column": 2
} | {
"line": 595,
"column": 41
} | [
{
"pp": "α : Type u_1\ninst✝ : PartialOrder α\na b : α\ns : Set α\nho : Ioo a b ⊆ s\nhc : s ⊆ Icc a b\n⊢ s ∈ {Icc a b, Ico a b, Ioc a b, Ioo a b}",
"usedConstants": [
"Set.Subset.antisymm",
"Eq.mpr",
"Set.Ioc",
"congrArg",
"PartialOrder.toPreorder",
"Set.diff_singleton_su... | classical
by_cases ha : a ∈ s <;> by_cases hb : b ∈ s
· refine Or.inl (Subset.antisymm hc ?_)
rwa [← Ico_diff_left, diff_singleton_subset_iff, insert_eq_of_mem ha, ← Icc_diff_right,
diff_singleton_subset_iff, insert_eq_of_mem hb] at ho
· refine Or.inr <| Or.inl <| Subset.antisymm ?_ ?_
·... | Lean.Elab.Tactic.evalClassical | Lean.Parser.Tactic.classical |
Mathlib.Order.Interval.Set.Basic | {
"line": 580,
"column": 2
} | {
"line": 595,
"column": 41
} | [
{
"pp": "α : Type u_1\ninst✝ : PartialOrder α\na b : α\ns : Set α\nho : Ioo a b ⊆ s\nhc : s ⊆ Icc a b\n⊢ s ∈ {Icc a b, Ico a b, Ioc a b, Ioo a b}",
"usedConstants": [
"Set.Subset.antisymm",
"Eq.mpr",
"Set.Ioc",
"congrArg",
"PartialOrder.toPreorder",
"Set.diff_singleton_su... | classical
by_cases ha : a ∈ s <;> by_cases hb : b ∈ s
· refine Or.inl (Subset.antisymm hc ?_)
rwa [← Ico_diff_left, diff_singleton_subset_iff, insert_eq_of_mem ha, ← Icc_diff_right,
diff_singleton_subset_iff, insert_eq_of_mem hb] at ho
· refine Or.inr <| Or.inl <| Subset.antisymm ?_ ?_
·... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Interval.Set.Basic | {
"line": 580,
"column": 2
} | {
"line": 595,
"column": 41
} | [
{
"pp": "α : Type u_1\ninst✝ : PartialOrder α\na b : α\ns : Set α\nho : Ioo a b ⊆ s\nhc : s ⊆ Icc a b\n⊢ s ∈ {Icc a b, Ico a b, Ioc a b, Ioo a b}",
"usedConstants": [
"Set.Subset.antisymm",
"Eq.mpr",
"Set.Ioc",
"congrArg",
"PartialOrder.toPreorder",
"Set.diff_singleton_su... | classical
by_cases ha : a ∈ s <;> by_cases hb : b ∈ s
· refine Or.inl (Subset.antisymm hc ?_)
rwa [← Ico_diff_left, diff_singleton_subset_iff, insert_eq_of_mem ha, ← Icc_diff_right,
diff_singleton_subset_iff, insert_eq_of_mem hb] at ho
· refine Or.inr <| Or.inl <| Subset.antisymm ?_ ?_
·... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Interval.Set.Basic | {
"line": 676,
"column": 2
} | {
"line": 677,
"column": 12
} | [
{
"pp": "α : Type u_1\ninst✝ : SemilatticeInf α\na b : α\n⊢ Iic a ∩ Iic b = Iic (a ⊓ b)",
"usedConstants": [
"Set.ext",
"congrArg",
"PartialOrder.toPreorder",
"setOf",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"SemilatticeInf.toMin",
... | ext x
simp [Iic] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Interval.Set.Basic | {
"line": 676,
"column": 2
} | {
"line": 677,
"column": 12
} | [
{
"pp": "α : Type u_1\ninst✝ : SemilatticeInf α\na b : α\n⊢ Iic a ∩ Iic b = Iic (a ⊓ b)",
"usedConstants": [
"Set.ext",
"congrArg",
"PartialOrder.toPreorder",
"setOf",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"SemilatticeInf.toMin",
... | ext x
simp [Iic] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Control.Basic | {
"line": 177,
"column": 2
} | {
"line": 177,
"column": 57
} | [
{
"pp": "α β γ : Type u\ne : Type v\n⊢ LawfulFunctor (Sum e)",
"usedConstants": [
"LawfulFunctor.mk",
"Monad.toApplicative",
"Function.comp",
"Sum.casesOn",
"Sum",
"id",
"Sum.inl",
"Sum.inr",
"Functor.mapConst",
"Applicative.toFunctor",
"Eq.r... | constructor <;> intros <;> (try casesm Sum _ _) <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Control.Basic | {
"line": 177,
"column": 2
} | {
"line": 177,
"column": 57
} | [
{
"pp": "α β γ : Type u\ne : Type v\n⊢ LawfulFunctor (Sum e)",
"usedConstants": [
"LawfulFunctor.mk",
"Monad.toApplicative",
"Function.comp",
"Sum.casesOn",
"Sum",
"id",
"Sum.inl",
"Sum.inr",
"Functor.mapConst",
"Applicative.toFunctor",
"Eq.r... | constructor <;> intros <;> (try casesm Sum _ _) <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Control.Basic | {
"line": 177,
"column": 2
} | {
"line": 177,
"column": 57
} | [
{
"pp": "α β γ : Type u\ne : Type v\n⊢ LawfulFunctor (Sum e)",
"usedConstants": [
"LawfulFunctor.mk",
"Monad.toApplicative",
"Function.comp",
"Sum.casesOn",
"Sum",
"id",
"Sum.inl",
"Sum.inr",
"Functor.mapConst",
"Applicative.toFunctor",
"Eq.r... | constructor <;> intros <;> (try casesm Sum _ _) <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Logic.Equiv.Set | {
"line": 63,
"column": 39
} | {
"line": 63,
"column": 84
} | [
{
"pp": "α : Type u_3\nβ : Type u_4\ne : α ≃ β\ns : Set α\nt : Set β\n⊢ ⇑e.symm '' t ⊆ s ↔ t ⊆ ⇑e '' s",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"congrArg",
"Iff.rfl",
"id",
"Equiv",
"HasSubset.Subset",
"Iff",
"Equiv.image_eq_preimage_symm",
... | rw [image_subset_iff, image_eq_preimage_symm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Logic.Equiv.Set | {
"line": 63,
"column": 39
} | {
"line": 63,
"column": 84
} | [
{
"pp": "α : Type u_3\nβ : Type u_4\ne : α ≃ β\ns : Set α\nt : Set β\n⊢ ⇑e.symm '' t ⊆ s ↔ t ⊆ ⇑e '' s",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"congrArg",
"Iff.rfl",
"id",
"Equiv",
"HasSubset.Subset",
"Iff",
"Equiv.image_eq_preimage_symm",
... | rw [image_subset_iff, image_eq_preimage_symm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Equiv.Set | {
"line": 63,
"column": 39
} | {
"line": 63,
"column": 84
} | [
{
"pp": "α : Type u_3\nβ : Type u_4\ne : α ≃ β\ns : Set α\nt : Set β\n⊢ ⇑e.symm '' t ⊆ s ↔ t ⊆ ⇑e '' s",
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"congrArg",
"Iff.rfl",
"id",
"Equiv",
"HasSubset.Subset",
"Iff",
"Equiv.image_eq_preimage_symm",
... | rw [image_subset_iff, image_eq_preimage_symm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.TakeDrop | {
"line": 40,
"column": 30
} | {
"line": 40,
"column": 35
} | [
{
"pp": "α : Type u\nl : List α\nn : ℕ\nh : n < l.length\n⊢ take 1 (l[n] :: drop (n + 1) l) = [l.get ⟨n, h⟩]",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.take.eq_3",
"List.get",
"Fin.mk",
"id",
"instOfNatNat",
"List.cons",
"GetElem.getElem",
"L... | take, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Field.Basic | {
"line": 475,
"column": 2
} | {
"line": 475,
"column": 33
} | [
{
"pp": "α : Type u_2\ninst✝³ : Field α\ninst✝² : PartialOrder α\ninst✝¹ : PosMulReflectLT α\ninst✝ : IsStrictOrderedRing α\na b : α\nha : a < 0\nhb : b < 0\n⊢ 1 / a ≤ b ↔ 1 / b ≤ a",
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"congrArg",
"PartialOrder.toPre... | simpa using inv_le_of_neg ha hb | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Order.Field.Basic | {
"line": 475,
"column": 2
} | {
"line": 475,
"column": 33
} | [
{
"pp": "α : Type u_2\ninst✝³ : Field α\ninst✝² : PartialOrder α\ninst✝¹ : PosMulReflectLT α\ninst✝ : IsStrictOrderedRing α\na b : α\nha : a < 0\nhb : b < 0\n⊢ 1 / a ≤ b ↔ 1 / b ≤ a",
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"congrArg",
"PartialOrder.toPre... | simpa using inv_le_of_neg ha hb | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Field.Basic | {
"line": 475,
"column": 2
} | {
"line": 475,
"column": 33
} | [
{
"pp": "α : Type u_2\ninst✝³ : Field α\ninst✝² : PartialOrder α\ninst✝¹ : PosMulReflectLT α\ninst✝ : IsStrictOrderedRing α\na b : α\nha : a < 0\nhb : b < 0\n⊢ 1 / a ≤ b ↔ 1 / b ≤ a",
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"congrArg",
"PartialOrder.toPre... | simpa using inv_le_of_neg ha hb | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Field.Basic | {
"line": 477,
"column": 79
} | {
"line": 478,
"column": 33
} | [
{
"pp": "α : Type u_2\ninst✝³ : Field α\ninst✝² : PartialOrder α\ninst✝¹ : PosMulReflectLT α\ninst✝ : IsStrictOrderedRing α\na b : α\nha : a < 0\nhb : b < 0\n⊢ 1 / a < b ↔ 1 / b < a",
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"Preorder.toLT",
"instHDiv",
"congrArg",
... | by
simpa using inv_lt_of_neg ha hb | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Forall2 | {
"line": 205,
"column": 4
} | {
"line": 205,
"column": 24
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nR : α → β → Prop\nhr : BiUnique R\na : α\nb : β\nh : R a b\na' : α\nas : List α\nb' : β\nbs : List β\nh₁ : R a' b'\nh₂ : Forall₂ R as bs\n⊢ (fun x1 x2 ↦ x1 ∈ x2) a (a' :: as) ↔ (fun x1 x2 ↦ x1 ∈ x2) b (b' :: bs)",
"usedConstants": [
"Eq.mpr",
"congrArg",
... | simp only [mem_cons] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Perm.Basic | {
"line": 68,
"column": 2
} | {
"line": 82,
"column": 63
} | [
{
"pp": "α : Type u_1\nl₁ l₂ : List α\nn : ℕ\na : α\n⊢ l₁.insertIdx n a ~ l₂.insertIdx n a ↔ l₁ ~ l₂",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Iff.rfl",
"_private.Mathlib.Data.List.Perm.Basic.0.List.perm_insertIdx_iff._proof_1_1",
"List.insertIdx",
"List.perm_comm",
... | wlog hle : length l₁ ≤ length l₂ generalizing l₁ l₂
· rw [perm_comm, this (Nat.le_of_not_ge hle), perm_comm]
cases Nat.lt_or_ge (length l₁) n with
| inl hn₁ =>
rw [insertIdx_of_length_lt hn₁]
cases Nat.lt_or_ge (length l₂) n with
| inl hn₂ => rw [insertIdx_of_length_lt hn₂]
| inr hn₂ =>
appl... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Perm.Basic | {
"line": 68,
"column": 2
} | {
"line": 82,
"column": 63
} | [
{
"pp": "α : Type u_1\nl₁ l₂ : List α\nn : ℕ\na : α\n⊢ l₁.insertIdx n a ~ l₂.insertIdx n a ↔ l₁ ~ l₂",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Iff.rfl",
"_private.Mathlib.Data.List.Perm.Basic.0.List.perm_insertIdx_iff._proof_1_1",
"List.insertIdx",
"List.perm_comm",
... | wlog hle : length l₁ ≤ length l₂ generalizing l₁ l₂
· rw [perm_comm, this (Nat.le_of_not_ge hle), perm_comm]
cases Nat.lt_or_ge (length l₁) n with
| inl hn₁ =>
rw [insertIdx_of_length_lt hn₁]
cases Nat.lt_or_ge (length l₂) n with
| inl hn₂ => rw [insertIdx_of_length_lt hn₂]
| inr hn₂ =>
appl... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Perm.Basic | {
"line": 152,
"column": 58
} | {
"line": 153,
"column": 81
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nr : α → β → Prop\nhr : RightUnique r\na : List α\nb : List β\nh₁ : Forall₂ r a b\nc : List α\nd : List β\nh₂ : Forall₂ r c d\nh : a ~ c\nthis : (flip (Forall₂ r) ∘r Perm ∘r Forall₂ r) b d\n⊢ ((flip (Forall₂ r) ∘r Forall₂ r) ∘r Perm) b d",
"usedConstants": [
"congrA... | by
rwa [← forall₂_comp_perm_eq_perm_comp_forall₂, ← Relation.comp_assoc] at this | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Perm.Basic | {
"line": 180,
"column": 2
} | {
"line": 180,
"column": 20
} | [
{
"pp": "case swap'\nα : Type u_1\nβ : Type u_2\nf : α → β → β\nl₁ l₂ : List α\nlcomm : LeftCommutative f\nx✝ y✝ : α\nl₁✝ l₂✝ : List α\nh✝ : l₁✝ ~ l₂✝\nr : ∀ (b : β), foldr f b l₁✝ = foldr f b l₂✝\nb : β\n⊢ foldr f b (y✝ :: x✝ :: l₁✝) = foldr f b (x✝ :: y✝ :: l₂✝)",
"usedConstants": [
"Eq.mpr",
... | | swap' _ _ _ r => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.List.Perm.Basic | {
"line": 236,
"column": 22
} | {
"line": 236,
"column": 36
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type u_2\nf g : α → List β\na : α\nl : List α\nIH : flatMap f l ++ flatMap g l ~ flatMap (fun x ↦ f x ++ g x) l\n⊢ flatMap f l ++ g a ++ flatMap g l ~ g a ++ (flatMap f l ++ flatMap g l)",
"usedConstants": [
"Eq.mpr",
"List.append_assoc",
"congrArg",
... | ← append_assoc | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.BigOperators.Group.List.Basic | {
"line": 309,
"column": 2
} | {
"line": 309,
"column": 31
} | [
{
"pp": "M : Type u_4\ninst✝ : LeftCancelMonoid M\nL L' : List M\nh : L.length = L'.length\nh' : ∀ (i : ℕ), i ≤ L.length → (take i L).prod = (take i L').prod\ni : ℕ\nh₁ : i < L.length\nh₂ : i < L'.length\nthis : (take i L').prod * L[i] = (take i L').prod * L'[i]\n⊢ L.get ⟨i, h₁⟩ = L'.get ⟨i, h₂⟩",
"usedCons... | convert! mul_left_cancel this | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_convert!_1 | Mathlib.Tactic.convert! |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.