tasksource/leandojo huggingface dataset:
Theorem: iSup_split_single
File: Mathlib/Order/CompleteLattice.lean

tactic: convert iSup_split f (fun i => i = i₀)
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.134534
γ : Type ?u.134537
ι : Sort ?u.134540
ι' : Sort ?u.134543
κ : ι → Sort ?u.134548
κ' : ι' → Sort ?u.134553
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β → α
i₀ : β
⊢ (⨆ (i : β), f i) = f i₀ ⊔ ⨆ (i : β) (_ : i ≠ i₀), f i

tactic: simp
state_before: case h.e'_3.h.e'_3
α : Type u_1
β : Type u_2
β₂ : Type ?u.134534
γ : Type ?u.134537
ι : Sort ?u.134540
ι' : Sort ?u.134543
κ : ι → Sort ?u.134548
κ' : ι' → Sort ?u.134553
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β → α
i₀ : β
⊢ f i₀ = ⨆ (i : β) (_ : i = i₀), f i
Theorem: mul_inv_le_one_iff_le
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [one_mul]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a ≤ 1 * b ↔ a ≤ b
Theorem: dist_le_norm_mul_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [dist_eq_norm_div]
state_before: 𝓕 : Type ?u.82158
𝕜 : Type ?u.82161
α : Type ?u.82164
ι : Type ?u.82167
κ : Type ?u.82170
E : Type u_1
F : Type ?u.82176
G : Type ?u.82179
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ dist a b ≤ ‖a‖ + ‖b‖

tactic: apply norm_div_le
state_before: 𝓕 : Type ?u.82158
𝕜 : Type ?u.82161
α : Type ?u.82164
ι : Type ?u.82167
κ : Type ?u.82170
E : Type u_1
F : Type ?u.82176
G : Type ?u.82179
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ ‖a / b‖ ≤ ‖a‖ + ‖b‖
Theorem: Polynomial.natDegree_comp_le
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: rw [h0, natDegree_zero]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
h0 : comp p q = 0
⊢ natDegree (comp p q) ≤ natDegree p * natDegree q

tactic: exact Nat.zero_le _
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
h0 : comp p q = 0
⊢ 0 ≤ natDegree p * natDegree q

tactic: rw [natDegree_C, Nat.cast_zero, zero_add, nsmul_eq_mul]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
h0 : ¬comp p q = 0
n : ℕ
hn : n ∈ support p
⊢ ↑(natDegree (↑C (coeff p n))) + n • ↑(natDegree q) = ↑(n * natDegree q)

tactic: simp
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
h0 : ¬comp p q = 0
n : ℕ
hn : n ∈ support p
⊢ ↑n * ↑(natDegree q) = ↑(n * natDegree q)
Theorem: Metric.lipschitz_infDist_set
File: Mathlib/Topology/MetricSpace/Closeds.lean

tactic: rw [dist_comm]
state_before: α : Type u
inst✝ : MetricSpace α
x : α
s t : NonemptyCompacts α
⊢ infDist x ↑s ≤ infDist x ↑t + dist s t

tactic: exact infDist_le_infDist_add_hausdorffDist (edist_ne_top t s)
state_before: α : Type u
inst✝ : MetricSpace α
x : α
s t : NonemptyCompacts α
⊢ infDist x ↑s ≤ infDist x ↑t + dist t s
Theorem: Multiset.dedup_nsmul
File: Mathlib/Data/Multiset/Dedup.lean

tactic: ext a
state_before: α : Type u_1
β : Type ?u.13180
inst✝ : DecidableEq α
s : Multiset α
n : ℕ
h0 : n ≠ 0
⊢ dedup (n • s) = dedup s

tactic: by_cases h : a ∈ s <;> simp [h, h0]
state_before: case a
α : Type u_1
β : Type ?u.13180
inst✝ : DecidableEq α
s : Multiset α
n : ℕ
h0 : n ≠ 0
a : α
⊢ count a (dedup (n • s)) = count a (dedup s)
Theorem: LucasLehmer.sZMod_eq_s
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: induction' i with i ih
state_before: p' i : ℕ
⊢ sZMod (p' + 2) i = ↑(s i)

tactic: dsimp [s, sZMod]
state_before: case zero
p' : ℕ
⊢ sZMod (p' + 2) zero = ↑(s zero)

tactic: norm_num
state_before: case zero
p' : ℕ
⊢ 4 = ↑4

tactic: push_cast [s, sZMod, ih]
state_before: case succ
p' i : ℕ
ih : sZMod (p' + 2) i = ↑(s i)
⊢ sZMod (p' + 2) (succ i) = ↑(s (succ i))

tactic: rfl
state_before: case succ
p' i : ℕ
ih : sZMod (p' + 2) i = ↑(s i)
⊢ ↑(s i) ^ 2 - 2 = ↑(s i) ^ 2 - 2
Theorem: CategoryTheory.Limits.limitUncurryIsoLimitCompLim_inv_π
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: rw [← cancel_epi (limitUncurryIsoLimitCompLim F).hom]
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ (limitUncurryIsoLimitCompLim F).inv ≫ limit.π (uncurry.obj F) (j, k) = limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k

tactic: simp
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ (limitUncurryIsoLimitCompLim F).hom ≫ (limitUncurryIsoLimitCompLim F).inv ≫ limit.π (uncurry.obj F) (j, k) =
    (limitUncurryIsoLimitCompLim F).hom ≫ limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k
Theorem: Ordnode.insert'.valid
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [insert'_eq_insertWith]
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : IsTotal α fun x x_1 => x ≤ x_1
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
t : Ordnode α
h : Valid t
⊢ Valid (insert' x t)

tactic: exact insertWith.valid _ _ (fun _ => id) h
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : IsTotal α fun x x_1 => x ≤ x_1
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
t : Ordnode α
h : Valid t
⊢ Valid (insertWith id x t)
Theorem: CategoryTheory.Bicategory.associator_inv_naturality_middle
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g g' : b ⟶ c
η : g ⟶ g'
h : c ⟶ d
⊢ f ◁ η ▷ h ≫ (α_ f g' h).inv = (α_ f g h).inv ≫ (f ◁ η) ▷ h
Theorem: PNat.add_sub_of_lt
File: Mathlib/Data/PNat/Basic.lean

tactic: rw [add_coe, sub_coe, if_pos h]
state_before: a b : ℕ+
h : a < b
⊢ ↑(a + (b - a)) = ↑b

tactic: exact add_tsub_cancel_of_le h.le
state_before: a b : ℕ+
h : a < b
⊢ ↑a + (↑b - ↑a) = ↑b
Theorem: Real.cos_sq_arctan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw_mod_cast [one_div, ← inv_one_add_tan_sq (cos_arctan_pos x).ne', tan_arctan]
state_before: x : ℝ
⊢ cos (arctan x) ^ 2 = ↑1 / (↑1 + x ^ 2)
Theorem: PrimeSpectrum.vanishingIdeal_singleton
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: simp [vanishingIdeal]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
x : PrimeSpectrum R
⊢ vanishingIdeal {x} = x.asIdeal
Theorem: Std.RBNode.All.ins
File: Std/Data/RBMap/WF.lean

tactic: induction t <;> unfold ins <;> simp [*]
state_before: α : Type u_1
p : α → Prop
cmp : α → α → Ordering
x : α
t : RBNode α
h₁ : p x
h₂ : All p t
⊢ All p (ins cmp x t)

tactic: split <;> cases ‹_=_› <;> split <;> simp at h₂ <;> simp [*]
state_before: case node
α : Type u_1
p : α → Prop
cmp : α → α → Ordering
x : α
h₁ : p x
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : All p l✝ → All p (ins cmp x l✝)
r_ih✝ : All p r✝ → All p (ins cmp x r✝)
h₂ : All p (node c✝ l✝ v✝ r✝)
⊢ All p
    (match node c✝ l✝ v✝ r✝ with
    | nil => node red nil x nil
    | node red a y b =>
      match cmp x y with
      | Ordering.lt => node red (ins cmp x a) y b
      | Ordering.gt => node red a y (ins cmp x b)
      | Ordering.eq => node red a x b
    | node black a y b =>
      match cmp x y with
      | Ordering.lt => balance1 (ins cmp x a) y b
      | Ordering.gt => balance2 a y (ins cmp x b)
      | Ordering.eq => node black a x b)
Theorem: UniformSpace.Completion.eq_of_dist_eq_zero
File: Mathlib/Topology/MetricSpace/Completion.lean

tactic: have : SeparatedSpace (Completion α) := by infer_instance
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y : Completion α
h : dist x y = 0
⊢ x = y

tactic: refine' separated_def.1 this x y fun s hs ↦ _
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y : Completion α
h : dist x y = 0
this : SeparatedSpace (Completion α)
⊢ x = y

tactic: rcases (Completion.mem_uniformity_dist s).1 hs with ⟨ε, εpos, hε⟩
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y : Completion α
h : dist x y = 0
this : SeparatedSpace (Completion α)
s : Set (Completion α × Completion α)
hs : s ∈ 𝓤 (Completion α)
⊢ (x, y) ∈ s

tactic: rw [← h] at εpos
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y : Completion α
h : dist x y = 0
this : SeparatedSpace (Completion α)
s : Set (Completion α × Completion α)
hs : s ∈ 𝓤 (Completion α)
ε : ℝ
εpos : ε > 0
hε : ∀ {a b : Completion α}, dist a b < ε → (a, b) ∈ s
⊢ (x, y) ∈ s

tactic: exact hε εpos
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y : Completion α
h : dist x y = 0
this : SeparatedSpace (Completion α)
s : Set (Completion α × Completion α)
hs : s ∈ 𝓤 (Completion α)
ε : ℝ
εpos : ε > dist x y
hε : ∀ {a b : Completion α}, dist a b < ε → (a, b) ∈ s
⊢ (x, y) ∈ s

tactic: infer_instance
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y : Completion α
h : dist x y = 0
⊢ SeparatedSpace (Completion α)
Theorem: WithTop.monotone_map_iff
File: Mathlib/Order/WithBot.lean

tactic: simp [Monotone]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.94162
δ : Type ?u.94165
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
⊢ ((Monotone fun a => map f ↑a) ∧ ∀ (x : α), map f ↑x ≤ map f ⊤) ↔ Monotone f
Theorem: tsum_le_of_sum_le'
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

tactic: by_cases hf : Summable f
state_before: ι : Type u_2
κ : Type ?u.25943
α : Type u_1
inst✝² : OrderedAddCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
ha₂ : 0 ≤ a₂
h : ∀ (s : Finset ι), ∑ i in s, f i ≤ a₂
⊢ (∑' (i : ι), f i) ≤ a₂

tactic: exact tsum_le_of_sum_le hf h
state_before: case pos
ι : Type u_2
κ : Type ?u.25943
α : Type u_1
inst✝² : OrderedAddCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
ha₂ : 0 ≤ a₂
h : ∀ (s : Finset ι), ∑ i in s, f i ≤ a₂
hf : Summable f
⊢ (∑' (i : ι), f i) ≤ a₂

tactic: rw [tsum_eq_zero_of_not_summable hf]
state_before: case neg
ι : Type u_2
κ : Type ?u.25943
α : Type u_1
inst✝² : OrderedAddCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
ha₂ : 0 ≤ a₂
h : ∀ (s : Finset ι), ∑ i in s, f i ≤ a₂
hf : ¬Summable f
⊢ (∑' (i : ι), f i) ≤ a₂

tactic: exact ha₂
state_before: case neg
ι : Type u_2
κ : Type ?u.25943
α : Type u_1
inst✝² : OrderedAddCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f g : ι → α
a a₁ a₂ : α
ha₂ : 0 ≤ a₂
h : ∀ (s : Finset ι), ∑ i in s, f i ≤ a₂
hf : ¬Summable f
⊢ 0 ≤ a₂
Theorem: affineIndependent_iff_not_collinear_of_ne
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: have hu : (Finset.univ : Finset (Fin 3)) = {i₁, i₂, i₃} := by
  fin_cases i₁ <;> fin_cases i₂ <;> fin_cases i₃ <;> simp only at h₁₂ h₁₃ h₂₃ ⊢
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.280484
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : Fin 3 → P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
⊢ AffineIndependent k p ↔ ¬Collinear k {p i₁, p i₂, p i₃}

tactic: rw [affineIndependent_iff_not_collinear, ← Set.image_univ, ← Finset.coe_univ, hu,
  Finset.coe_insert, Finset.coe_insert, Finset.coe_singleton, Set.image_insert_eq, Set.image_pair]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.280484
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : Fin 3 → P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
hu : Finset.univ = {i₁, i₂, i₃}
⊢ AffineIndependent k p ↔ ¬Collinear k {p i₁, p i₂, p i₃}

tactic: fin_cases i₁ <;> fin_cases i₂ <;> fin_cases i₃ <;> simp only at h₁₂ h₁₃ h₂₃ ⊢
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.280484
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : Fin 3 → P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
⊢ Finset.univ = {i₁, i₂, i₃}
Theorem: List.foldr_append
File: Std/Data/List/Init/Lemmas.lean

tactic: simp [foldr_eq_foldrM]
state_before: α : Type u_1
β : Type u_2
f : α → β → β
b : β
l l' : List α
⊢ foldr f b (l ++ l') = foldr f (foldr f b l') l
Theorem: Submodule.topologicalClosure_eq_top_iff
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [← Submodule.orthogonal_orthogonal_eq_closure]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.886369
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace E
⊢ topologicalClosure K = ⊤ ↔ Kᗮ = ⊥

tactic: constructor <;> intro h
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.886369
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace E
⊢ Kᗮᗮ = ⊤ ↔ Kᗮ = ⊥

tactic: rw [← Submodule.triorthogonal_eq_orthogonal, h, Submodule.top_orthogonal_eq_bot]
state_before: case mp
𝕜 : Type u_2
E : Type u_1
F : Type ?u.886369
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace E
h : Kᗮᗮ = ⊤
⊢ Kᗮ = ⊥

tactic: rw [h, Submodule.bot_orthogonal_eq_top]
state_before: case mpr
𝕜 : Type u_2
E : Type u_1
F : Type ?u.886369
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace E
h : Kᗮ = ⊥
⊢ Kᗮᗮ = ⊤
Theorem: Convex.gauge_le
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: by_cases ha : 0 ≤ a
state_before: 𝕜 : Type ?u.77419
E : Type u_1
F : Type ?u.77425
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a✝ : ℝ
hs : Convex ℝ s
h₀ : 0 ∈ s
absorbs : Absorbent ℝ s
a : ℝ
⊢ Convex ℝ {x | gauge s x ≤ a}

tactic: rw [gauge_le_eq hs h₀ absorbs ha]
state_before: case pos
𝕜 : Type ?u.77419
E : Type u_1
F : Type ?u.77425
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a✝ : ℝ
hs : Convex ℝ s
h₀ : 0 ∈ s
absorbs : Absorbent ℝ s
a : ℝ
ha : 0 ≤ a
⊢ Convex ℝ {x | gauge s x ≤ a}

tactic: exact convex_iInter fun i => convex_iInter fun _ => hs.smul _
state_before: case pos
𝕜 : Type ?u.77419
E : Type u_1
F : Type ?u.77425
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a✝ : ℝ
hs : Convex ℝ s
h₀ : 0 ∈ s
absorbs : Absorbent ℝ s
a : ℝ
ha : 0 ≤ a
⊢ Convex ℝ (⋂ (r : ℝ) (_ : a < r), r • s)

tactic: convert convex_empty (𝕜 := ℝ) (E := E)
state_before: case neg
𝕜 : Type ?u.77419
E : Type u_1
F : Type ?u.77425
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a✝ : ℝ
hs : Convex ℝ s
h₀ : 0 ∈ s
absorbs : Absorbent ℝ s
a : ℝ
ha : ¬0 ≤ a
⊢ Convex ℝ {x | gauge s x ≤ a}

tactic: exact eq_empty_iff_forall_not_mem.2 fun x hx => ha <| (gauge_nonneg _).trans hx
state_before: case h.e'_6
𝕜 : Type ?u.77419
E : Type u_1
F : Type ?u.77425
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a✝ : ℝ
hs : Convex ℝ s
h₀ : 0 ∈ s
absorbs : Absorbent ℝ s
a : ℝ
ha : ¬0 ≤ a
⊢ {x | gauge s x ≤ a} = ∅
Theorem: FirstOrder.Language.Substructure.cg_iff_structure_cg
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [Structure.cg_def]
state_before: L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
⊢ CG S ↔ Structure.CG L { x // x ∈ S }

tactic: refine' ⟨fun h => CG.of_map_embedding S.subtype _, fun h => _⟩
state_before: L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
⊢ CG S ↔ CG ⊤

tactic: rw [← Hom.range_eq_map, range_subtype]
state_before: case refine'_1
L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
h : CG S
⊢ CG (map (Embedding.toHom (subtype S)) ⊤)

tactic: exact h
state_before: case refine'_1
L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
h : CG S
⊢ CG S

tactic: have h := h.map S.subtype.toHom
state_before: case refine'_2
L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
h : CG ⊤
⊢ CG S

tactic: rw [← Hom.range_eq_map, range_subtype] at h
state_before: case refine'_2
L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
h✝ : CG ⊤
h : CG (map (Embedding.toHom (subtype S)) ⊤)
⊢ CG S

tactic: exact h
state_before: case refine'_2
L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
h✝ : CG ⊤
h : CG S
⊢ CG S
Theorem: PNat.Coprime.symm
File: Mathlib/Data/PNat/Prime.lean

tactic: unfold Coprime
state_before: m n : ℕ+
⊢ Coprime m n → Coprime n m

tactic: rw [gcd_comm]
state_before: m n : ℕ+
⊢ gcd m n = 1 → gcd n m = 1

tactic: simp
state_before: m n : ℕ+
⊢ gcd n m = 1 → gcd n m = 1
Theorem: Polynomial.coeff_X_pow_mul
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: rw [(commute_X_pow p n).eq, coeff_mul_X_pow]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n d : ℕ
⊢ coeff (X ^ n * p) (d + n) = coeff p d
Theorem: Polynomial.card_rootSet_le_derivative
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: simpa only [rootSet_def, Finset.coe_sort_coe, Fintype.card_coe, derivative_map] using
  card_roots_toFinset_le_derivative (p.map (algebraMap F ℝ))
state_before: F : Type u_1
inst✝¹ : CommRing F
inst✝ : Algebra F ℝ
p : F[X]
⊢ Fintype.card ↑(rootSet p ℝ) ≤ Fintype.card ↑(rootSet (↑derivative p) ℝ) + 1
Theorem: IsPGroup.coprime_card_of_ne
File: Mathlib/GroupTheory/PGroup.lean

tactic: obtain ⟨n₁, heq₁⟩ := iff_card.mp hH₁
state_before: p : ℕ
G : Type u_2
inst✝³ : Group G
G₂ : Type u_1
inst✝² : Group G₂
p₁ p₂ : ℕ
hp₁ : Fact (Nat.Prime p₁)
hp₂ : Fact (Nat.Prime p₂)
hne : p₁ ≠ p₂
H₁ : Subgroup G
H₂ : Subgroup G₂
inst✝¹ : Fintype { x // x ∈ H₁ }
inst✝ : Fintype { x // x ∈ H₂ }
hH₁ : IsPGroup p₁ { x // x ∈ H₁ }
hH₂ : IsPGroup p₂ { x // x ∈ H₂ }
⊢ Nat.coprime (card { x // x ∈ H₁ }) (card { x // x ∈ H₂ })

tactic: rw [heq₁]
state_before: case intro
p : ℕ
G : Type u_2
inst✝³ : Group G
G₂ : Type u_1
inst✝² : Group G₂
p₁ p₂ : ℕ
hp₁ : Fact (Nat.Prime p₁)
hp₂ : Fact (Nat.Prime p₂)
hne : p₁ ≠ p₂
H₁ : Subgroup G
H₂ : Subgroup G₂
inst✝¹ : Fintype { x // x ∈ H₁ }
inst✝ : Fintype { x // x ∈ H₂ }
hH₁ : IsPGroup p₁ { x // x ∈ H₁ }
hH₂ : IsPGroup p₂ { x // x ∈ H₂ }
n₁ : ℕ
heq₁ : card { x // x ∈ H₁ } = p₁ ^ n₁
⊢ Nat.coprime (card { x // x ∈ H₁ }) (card { x // x ∈ H₂ })

tactic: clear heq₁
state_before: case intro
p : ℕ
G : Type u_2
inst✝³ : Group G
G₂ : Type u_1
inst✝² : Group G₂
p₁ p₂ : ℕ
hp₁ : Fact (Nat.Prime p₁)
hp₂ : Fact (Nat.Prime p₂)
hne : p₁ ≠ p₂
H₁ : Subgroup G
H₂ : Subgroup G₂
inst✝¹ : Fintype { x // x ∈ H₁ }
inst✝ : Fintype { x // x ∈ H₂ }
hH₁ : IsPGroup p₁ { x // x ∈ H₁ }
hH₂ : IsPGroup p₂ { x // x ∈ H₂ }
n₁ : ℕ
heq₁ : card { x // x ∈ H₁ } = p₁ ^ n₁
⊢ Nat.coprime (p₁ ^ n₁) (card { x // x ∈ H₂ })

tactic: obtain ⟨n₂, heq₂⟩ := iff_card.mp hH₂
state_before: case intro
p : ℕ
G : Type u_2
inst✝³ : Group G
G₂ : Type u_1
inst✝² : Group G₂
p₁ p₂ : ℕ
hp₁ : Fact (Nat.Prime p₁)
hp₂ : Fact (Nat.Prime p₂)
hne : p₁ ≠ p₂
H₁ : Subgroup G
H₂ : Subgroup G₂
inst✝¹ : Fintype { x // x ∈ H₁ }
inst✝ : Fintype { x // x ∈ H₂ }
hH₁ : IsPGroup p₁ { x // x ∈ H₁ }
hH₂ : IsPGroup p₂ { x // x ∈ H₂ }
n₁ : ℕ
⊢ Nat.coprime (p₁ ^ n₁) (card { x // x ∈ H₂ })

tactic: rw [heq₂]
state_before: case intro.intro
p : ℕ
G : Type u_2
inst✝³ : Group G
G₂ : Type u_1
inst✝² : Group G₂
p₁ p₂ : ℕ
hp₁ : Fact (Nat.Prime p₁)
hp₂ : Fact (Nat.Prime p₂)
hne : p₁ ≠ p₂
H₁ : Subgroup G
H₂ : Subgroup G₂
inst✝¹ : Fintype { x // x ∈ H₁ }
inst✝ : Fintype { x // x ∈ H₂ }
hH₁ : IsPGroup p₁ { x // x ∈ H₁ }
hH₂ : IsPGroup p₂ { x // x ∈ H₂ }
n₁ n₂ : ℕ
heq₂ : card { x // x ∈ H₂ } = p₂ ^ n₂
⊢ Nat.coprime (p₁ ^ n₁) (card { x // x ∈ H₂ })

tactic: clear heq₂
state_before: case intro.intro
p : ℕ
G : Type u_2
inst✝³ : Group G
G₂ : Type u_1
inst✝² : Group G₂
p₁ p₂ : ℕ
hp₁ : Fact (Nat.Prime p₁)
hp₂ : Fact (Nat.Prime p₂)
hne : p₁ ≠ p₂
H₁ : Subgroup G
H₂ : Subgroup G₂
inst✝¹ : Fintype { x // x ∈ H₁ }
inst✝ : Fintype { x // x ∈ H₂ }
hH₁ : IsPGroup p₁ { x // x ∈ H₁ }
hH₂ : IsPGroup p₂ { x // x ∈ H₂ }
n₁ n₂ : ℕ
heq₂ : card { x // x ∈ H₂ } = p₂ ^ n₂
⊢ Nat.coprime (p₁ ^ n₁) (p₂ ^ n₂)

tactic: exact Nat.coprime_pow_primes _ _ hp₁.elim hp₂.elim hne
state_before: case intro.intro
p : ℕ
G : Type u_2
inst✝³ : Group G
G₂ : Type u_1
inst✝² : Group G₂
p₁ p₂ : ℕ
hp₁ : Fact (Nat.Prime p₁)
hp₂ : Fact (Nat.Prime p₂)
hne : p₁ ≠ p₂
H₁ : Subgroup G
H₂ : Subgroup G₂
inst✝¹ : Fintype { x // x ∈ H₁ }
inst✝ : Fintype { x // x ∈ H₂ }
hH₁ : IsPGroup p₁ { x // x ∈ H₁ }
hH₂ : IsPGroup p₂ { x // x ∈ H₂ }
n₁ n₂ : ℕ
⊢ Nat.coprime (p₁ ^ n₁) (p₂ ^ n₂)
Theorem: Subgroup.relindex_inf_mul_relindex
File: Mathlib/GroupTheory/Index.lean

tactic: rw [← inf_relindex_right H (K ⊓ L), ← inf_relindex_right K L, ← inf_relindex_right (H ⊓ K) L,
  inf_assoc, relindex_mul_relindex (H ⊓ (K ⊓ L)) (K ⊓ L) L inf_le_right inf_le_right]
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ relindex H (K ⊓ L) * relindex K L = relindex (H ⊓ K) L
Theorem: padicValRat.of_int_multiplicity
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [of_int, padicValInt.of_ne_one_ne_zero hp hz]
state_before: p : ℕ
z : ℤ
hp : p ≠ 1
hz : z ≠ 0
⊢ padicValRat p ↑z = ↑(Part.get (multiplicity (↑p) z) (_ : multiplicity.Finite (↑p) z))
Theorem: Nat.sInf_le
File: Mathlib/Data/Nat/Lattice.lean

tactic: rw [Nat.sInf_def ⟨m, hm⟩]
state_before: s : Set ℕ
m : ℕ
hm : m ∈ s
⊢ sInf s ≤ m

tactic: exact Nat.find_min' ⟨m, hm⟩ hm
state_before: s : Set ℕ
m : ℕ
hm : m ∈ s
⊢ Nat.find (_ : ∃ x, x ∈ s) ≤ m
Theorem: ContinuousMap.image_coev
File: Mathlib/Topology/CompactOpen.lean

tactic: aesop
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.40917
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
y : β
s : Set α
⊢ ↑(coev α β y) '' s = {y} ×ˢ s
Theorem: abs_le_abs_of_nonpos
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [abs_of_nonpos ha, abs_of_nonpos (hab.trans ha)]
state_before: α : Type u_1
inst✝³ : AddGroup α
inst✝² : LinearOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
ha : a ≤ 0
hab : b ≤ a
⊢ abs a ≤ abs b

tactic: exact neg_le_neg_iff.mpr hab
state_before: α : Type u_1
inst✝³ : AddGroup α
inst✝² : LinearOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
ha : a ≤ 0
hab : b ≤ a
⊢ -a ≤ -b
Theorem: MeasureTheory.SignedMeasure.findExistsOneDivLT_min
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

tactic: rw [findExistsOneDivLT, dif_pos hi] at hm
state_before: α : Type u_1
β : Type ?u.3427
inst✝³ : MeasurableSpace α
M : Type ?u.3433
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
m : ℕ
hm : m < MeasureTheory.SignedMeasure.findExistsOneDivLT s i
⊢ ¬MeasureTheory.SignedMeasure.ExistsOneDivLT s i m

tactic: exact Nat.find_min _ hm
state_before: α : Type u_1
β : Type ?u.3427
inst✝³ : MeasurableSpace α
M : Type ?u.3433
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
m : ℕ
hm : m < Nat.find (_ : ∃ n, MeasureTheory.SignedMeasure.ExistsOneDivLT s i n)
⊢ ¬MeasureTheory.SignedMeasure.ExistsOneDivLT s i m