tasksource/leandojo huggingface dataset:
Theorem: CompositionSeries.mem_eraseTop_of_ne_of_mem
File: Mathlib/Order/JordanHolder.lean

tactic: rcases hxs with ⟨i, rfl⟩
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
x : X
hx : x ≠ top s
hxs : x ∈ s
⊢ x ∈ eraseTop s

tactic: have hi : (i : ℕ) < (s.length - 1).succ := by
  conv_rhs => rw [← Nat.succ_sub (length_pos_of_mem_ne ⟨i, rfl⟩ s.top_mem hx), Nat.succ_sub_one]
  exact lt_of_le_of_ne (Nat.le_of_lt_succ i.2) (by simpa [top, s.inj, Fin.ext_iff] using hx)
state_before: case intro
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : Fin (s.length + 1)
hx : series s i ≠ top s
⊢ series s i ∈ eraseTop s

tactic: refine' ⟨Fin.castSucc i, _⟩
state_before: case intro
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : Fin (s.length + 1)
hx : series s i ≠ top s
hi : ↑i < Nat.succ (s.length - 1)
⊢ series s i ∈ eraseTop s

tactic: simp [Fin.ext_iff, Nat.mod_eq_of_lt hi]
state_before: case intro
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : Fin (s.length + 1)
hx : series s i ≠ top s
hi : ↑i < Nat.succ (s.length - 1)
⊢ series (eraseTop s) ↑↑(↑Fin.castSucc i) = series s i

tactic: conv_rhs => rw [← Nat.succ_sub (length_pos_of_mem_ne ⟨i, rfl⟩ s.top_mem hx), Nat.succ_sub_one]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : Fin (s.length + 1)
hx : series s i ≠ top s
⊢ ↑i < Nat.succ (s.length - 1)

tactic: exact lt_of_le_of_ne (Nat.le_of_lt_succ i.2) (by simpa [top, s.inj, Fin.ext_iff] using hx)
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : Fin (s.length + 1)
hx : series s i ≠ top s
⊢ ↑i < s.length

tactic: simpa [top, s.inj, Fin.ext_iff] using hx
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : Fin (s.length + 1)
hx : series s i ≠ top s
⊢ ↑i ≠ s.length
Theorem: GeneralizedContinuedFraction.terminatedAt_iff_part_num_none
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: rw [terminatedAt_iff_s_none, part_num_none_iff_s_none]
state_before: α : Type u_1
g : GeneralizedContinuedFraction α
n : ℕ
⊢ TerminatedAt g n ↔ Stream'.Seq.get? (partialNumerators g) n = none
Theorem: PiNat.min_firstDiff_le
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: by_contra' H
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
⊢ min (firstDiff x y) (firstDiff y z) ≤ firstDiff x z

tactic: rw [lt_min_iff] at H
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < min (firstDiff x y) (firstDiff y z)
⊢ False

tactic: refine apply_firstDiff_ne h ?_
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < firstDiff x y ∧ firstDiff x z < firstDiff y z
⊢ False

tactic: calc
  x (firstDiff x z) = y (firstDiff x z) := apply_eq_of_lt_firstDiff H.1
  _ = z (firstDiff x z) := apply_eq_of_lt_firstDiff H.2
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < firstDiff x y ∧ firstDiff x z < firstDiff y z
⊢ x (firstDiff x z) = z (firstDiff x z)
Theorem: uniqueDiffOn_Iic
File: Mathlib/Analysis/Calculus/TangentCone.lean

tactic: simp only [interior_Iic, nonempty_Iio]
state_before: 𝕜 : Type ?u.176943
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type ?u.176949
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.177044
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.177134
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
a : ℝ
⊢ Set.Nonempty (interior (Iic a))
Theorem: Function.IsPeriodicPt.add
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [IsPeriodicPt, iterate_add]
state_before: α : Type u_1
β : Type ?u.950
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hn : IsPeriodicPt f n x
hm : IsPeriodicPt f m x
⊢ IsPeriodicPt f (n + m) x

tactic: exact hn.comp hm
state_before: α : Type u_1
β : Type ?u.950
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hn : IsPeriodicPt f n x
hm : IsPeriodicPt f m x
⊢ IsFixedPt (f^[n] ∘ f^[m]) x
Theorem: CategoryTheory.Limits.BinaryCofan.isColimit_iff_isIso_inr
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: refine' Iff.trans _ (BinaryCofan.isColimit_iff_isIso_inl h (BinaryCofan.mk c.inr c.inl))
state_before: C : Type u
inst✝ : Category C
X✝ Y✝ X Y : C
h : IsInitial X
c : BinaryCofan X Y
⊢ Nonempty (IsColimit c) ↔ IsIso (inr c)

tactic: exact
  ⟨fun h => ⟨BinaryCofan.isColimitFlip h.some⟩, fun h =>
    ⟨(BinaryCofan.isColimitFlip h.some).ofIsoColimit (isoBinaryCofanMk c).symm⟩⟩
state_before: C : Type u
inst✝ : Category C
X✝ Y✝ X Y : C
h : IsInitial X
c : BinaryCofan X Y
⊢ Nonempty (IsColimit c) ↔ Nonempty (IsColimit (mk (inr c) (inl c)))
Theorem: mul_pos_of_neg_of_neg
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [zero_mul] using mul_lt_mul_of_neg_right ha hb
state_before: α : Type u
β : Type ?u.86888
inst✝ : StrictOrderedRing α
a✝ b✝ c a b : α
ha : a < 0
hb : b < 0
⊢ 0 < a * b
Theorem: CategoryTheory.Presieve.ofArrows_pullback
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: funext T
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z✝ : C
f : Y ⟶ X
inst✝ : HasPullbacks C
ι : Type u_1
Z : ι → C
g : (i : ι) → Z i ⟶ X
⊢ (ofArrows (fun i => pullback (g i) f) fun i => pullback.snd) = pullbackArrows f (ofArrows Z g)

tactic: ext h
state_before: case h
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z✝ : C
f : Y ⟶ X
inst✝ : HasPullbacks C
ι : Type u_1
Z : ι → C
g : (i : ι) → Z i ⟶ X
T : C
⊢ (ofArrows (fun i => pullback (g i) f) fun i => pullback.snd) = pullbackArrows f (ofArrows Z g)

tactic: constructor
state_before: case h.h
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z✝ : C
f : Y ⟶ X
inst✝ : HasPullbacks C
ι : Type u_1
Z : ι → C
g : (i : ι) → Z i ⟶ X
T : C
h : T ⟶ Y
⊢ (h ∈ ofArrows (fun i => pullback (g i) f) fun i => pullback.snd) ↔ h ∈ pullbackArrows f (ofArrows Z g)

tactic: rintro ⟨hk⟩
state_before: case h.h.mp
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z✝ : C
f : Y ⟶ X
inst✝ : HasPullbacks C
ι : Type u_1
Z : ι → C
g : (i : ι) → Z i ⟶ X
T : C
h : T ⟶ Y
⊢ (h ∈ ofArrows (fun i => pullback (g i) f) fun i => pullback.snd) → h ∈ pullbackArrows f (ofArrows Z g)

tactic: exact pullbackArrows.mk _ _ (ofArrows.mk hk)
state_before: case h.h.mp.mk
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y✝ Z✝ : C
f : Y✝ ⟶ X
inst✝ : HasPullbacks C
ι : Type u_1
Z : ι → C
g : (i : ι) → Z i ⟶ X
Y : C
hk : ι
⊢ pullback.snd ∈ pullbackArrows f (ofArrows Z g)

tactic: rintro ⟨W, k, hk₁⟩
state_before: case h.h.mpr
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z✝ : C
f : Y ⟶ X
inst✝ : HasPullbacks C
ι : Type u_1
Z : ι → C
g : (i : ι) → Z i ⟶ X
T : C
h : T ⟶ Y
⊢ h ∈ pullbackArrows f (ofArrows Z g) → h ∈ ofArrows (fun i => pullback (g i) f) fun i => pullback.snd

tactic: cases' hk₁ with i hi
state_before: case h.h.mpr.mk
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y✝ Z✝ : C
f : Y✝ ⟶ X
inst✝ : HasPullbacks C
ι : Type u_1
Z : ι → C
g : (i : ι) → Z i ⟶ X
Y W : C
k : W ⟶ X
hk₁ : ofArrows Z g k
⊢ pullback.snd ∈ ofArrows (fun i => pullback (g i) f) fun i => pullback.snd

tactic: apply ofArrows.mk
state_before: case h.h.mpr.mk.mk
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y✝ Z✝ : C
f : Y✝ ⟶ X
inst✝ : HasPullbacks C
ι : Type u_1
Z : ι → C
g : (i : ι) → Z i ⟶ X
Y : C
i : ι
⊢ pullback.snd ∈ ofArrows (fun i => pullback (g i) f) fun i => pullback.snd
Theorem: Int.lt_neg_of_lt_neg
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.neg_lt_neg h
state_before: a b : Int
h : a < -b
⊢ b < -a

tactic: rwa [Int.neg_neg] at h
state_before: a b : Int
h✝ : a < -b
h : - -b < -a
⊢ b < -a
Theorem: Commute.mul_inv_cancel_assoc
File: Mathlib/Algebra/Group/Commute.lean

tactic: rw [← mul_assoc, h.mul_inv_cancel]
state_before: G : Type u_1
inst✝ : Group G
a b : G
h : Commute a b
⊢ a * (b * a⁻¹) = b
Theorem: UV.compression_idem
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

tactic: have h : filter (fun a => compress u v a ∉ 𝓒 u v s) (𝓒 u v s) = ∅ :=
  filter_false_of_mem fun a ha h => h <| compress_mem_compression_of_mem_compression ha
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v✝ a b u v : α
s : Finset α
⊢ 𝓒 u v (𝓒 u v s) = 𝓒 u v s

tactic: rw [compression, image_filter]
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v✝ a b u v : α
s : Finset α
h : filter (fun a => ¬compress u v a ∈ 𝓒 u v s) (𝓒 u v s) = ∅
⊢ 𝓒 u v (𝓒 u v s) = 𝓒 u v s

tactic: simp_rw [Function.comp]
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v✝ a b u v : α
s : Finset α
h : filter (fun a => ¬compress u v a ∈ 𝓒 u v s) (𝓒 u v s) = ∅
⊢ filter (fun a => compress u v a ∈ 𝓒 u v s) (𝓒 u v s) ∪
      image (compress u v) (filter ((fun a => ¬a ∈ 𝓒 u v s) ∘ compress u v) (𝓒 u v s)) =
    𝓒 u v s

tactic: rw [h, image_empty, ← h]
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v✝ a b u v : α
s : Finset α
h : filter (fun a => ¬compress u v a ∈ 𝓒 u v s) (𝓒 u v s) = ∅
⊢ filter (fun a => compress u v a ∈ 𝓒 u v s) (𝓒 u v s) ∪
      image (compress u v) (filter (fun x => ¬compress u v x ∈ 𝓒 u v s) (𝓒 u v s)) =
    𝓒 u v s

tactic: exact filter_union_filter_neg_eq _ (compression u v s)
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v✝ a b u v : α
s : Finset α
h : filter (fun a => ¬compress u v a ∈ 𝓒 u v s) (𝓒 u v s) = ∅
⊢ filter (fun a => compress u v a ∈ 𝓒 u v s) (𝓒 u v s) ∪ filter (fun a => ¬compress u v a ∈ 𝓒 u v s) (𝓒 u v s) = 𝓒 u v s
Theorem: CategoryTheory.Bicategory.inv_hom_whiskerRight
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: rw [← comp_whiskerRight, inv_hom_id, id_whiskerRight]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ≅ g
h : b ⟶ c
⊢ η.inv ▷ h ≫ η.hom ▷ h = 𝟙 (g ≫ h)
Theorem: Subgroup.closure_preimage_eq_top
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: apply map_injective (closure s).subtype_injective
state_before: G : Type u_1
G' : Type ?u.604785
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.604794
inst✝¹ : AddGroup A
N : Type ?u.604800
inst✝ : Group N
f : G →* N
s : Set G
⊢ closure (↑(Subgroup.subtype (closure s)) ⁻¹' s) = ⊤

tactic: rw [MonoidHom.map_closure, ← MonoidHom.range_eq_map, subtype_range,
  Set.image_preimage_eq_of_subset]
state_before: case a
G : Type u_1
G' : Type ?u.604785
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.604794
inst✝¹ : AddGroup A
N : Type ?u.604800
inst✝ : Group N
f : G →* N
s : Set G
⊢ map (Subgroup.subtype (closure s)) (closure (↑(Subgroup.subtype (closure s)) ⁻¹' s)) =
    map (Subgroup.subtype (closure s)) ⊤

tactic: rw [coeSubtype, Subtype.range_coe_subtype]
state_before: case a
G : Type u_1
G' : Type ?u.604785
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.604794
inst✝¹ : AddGroup A
N : Type ?u.604800
inst✝ : Group N
f : G →* N
s : Set G
⊢ s ⊆ Set.range ↑(Subgroup.subtype (closure s))

tactic: exact subset_closure
state_before: case a
G : Type u_1
G' : Type ?u.604785
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.604794
inst✝¹ : AddGroup A
N : Type ?u.604800
inst✝ : Group N
f : G →* N
s : Set G
⊢ s ⊆ {x | x ∈ ↑(closure s)}
Theorem: MeasureTheory.OuterMeasure.comap_top
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [comap_apply, top_apply hs, top_apply (hs.image _)]
state_before: α : Type u_1
β : Type u_2
R : Type ?u.126810
R' : Type ?u.126813
ms : Set (OuterMeasure α)
m : OuterMeasure α
f : α → β
s : Set α
hs : Set.Nonempty s
⊢ ↑(↑(comap f) ⊤) s = ↑⊤ s
Theorem: LocalizedModule.zero_mk
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [one_smul, smul_zero, smul_zero, one_smul]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
⊢ 1 • 1 • 0 = 1 • s • 0
Theorem: MeasureTheory.ae_restrict_biUnion_finset_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp_rw [Filter.Eventually, ae_restrict_biUnion_finset_eq s, mem_iSup]
state_before: α : Type u_1
β : Type ?u.562282
γ : Type ?u.562285
δ : Type ?u.562288
ι : Type u_2
R : Type ?u.562294
R' : Type ?u.562297
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
s : ι → Set α
t : Finset ι
p : α → Prop
⊢ (∀ᵐ (x : α) ∂Measure.restrict μ (⋃ (i : ι) (_ : i ∈ t), s i), p x) ↔
    ∀ (i : ι), i ∈ t → ∀ᵐ (x : α) ∂Measure.restrict μ (s i), p x
Theorem: Set.iUnion_smul_eq_setOf_exists
File: Mathlib/Data/Set/Pointwise/SMul.lean

tactic: simp_rw [← iUnion_setOf, ← iUnion_inv_smul, ← preimage_smul, preimage]
state_before: F : Type ?u.153411
α : Type u_2
β : Type u_1
γ : Type ?u.153420
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a : α
x : β
s : Set β
⊢ (⋃ (g : α), g • s) = {a | ∃ g, g • a ∈ s}
Theorem: List.Chain'.count_not_eq_count
File: Mathlib/Data/Bool/Count.lean

tactic: cases' l with x l
state_before: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
h2 : Even (length l)
b : Bool
⊢ count (!b) l = count b l

tactic: rw [length_cons, Nat.even_add_one, Nat.not_even_iff] at h2
state_before: case cons
b x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
h2 : Even (length (x :: l))
⊢ count (!b) (x :: l) = count b (x :: l)

tactic: suffices count (!x) (x :: l) = count x (x :: l) by
  cases b <;> cases x <;>
  revert this <;> simp only [Bool.not_false, Bool.not_true] <;> intro this <;>
  (try exact this) <;> exact this.symm
state_before: case cons
b x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
h2 : length l % 2 = 1
⊢ count (!b) (x :: l) = count b (x :: l)

tactic: rw [count_cons_of_ne x.not_ne_self, hl.count_not, h2, count_cons_self]
state_before: case cons
b x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
h2 : length l % 2 = 1
⊢ count (!x) (x :: l) = count x (x :: l)

tactic: rfl
state_before: case nil
b : Bool
hl : Chain' (fun x x_1 => x ≠ x_1) []
h2 : Even (length [])
⊢ count (!b) [] = count b []

tactic: cases b <;> cases x <;>
revert this <;> simp only [Bool.not_false, Bool.not_true] <;> intro this <;>
(try exact this) <;> exact this.symm
state_before: b x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
h2 : length l % 2 = 1
this : count (!x) (x :: l) = count x (x :: l)
⊢ count (!b) (x :: l) = count b (x :: l)

tactic: try exact this
state_before: case true.true
l : List Bool
h2 : length l % 2 = 1
hl : Chain' (fun x x_1 => x ≠ x_1) (true :: l)
this : count false (true :: l) = count true (true :: l)
⊢ count false (true :: l) = count true (true :: l)

tactic: exact this
state_before: case true.true
l : List Bool
h2 : length l % 2 = 1
hl : Chain' (fun x x_1 => x ≠ x_1) (true :: l)
this : count false (true :: l) = count true (true :: l)
⊢ count false (true :: l) = count true (true :: l)
Theorem: LinearMap.quotientInfEquivSupQuotient_surjective
File: Mathlib/LinearAlgebra/Isomorphisms.lean

tactic: rw [← range_eq_top, quotientInfToSupQuotient, range_liftQ, eq_top_iff']
state_before: R : Type u_1
M : Type u_2
M₂ : Type ?u.65976
M₃ : Type ?u.65979
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
⊢ Function.Surjective ↑(quotientInfToSupQuotient p p')

tactic: rintro ⟨x, hx⟩
state_before: R : Type u_1
M : Type u_2
M₂ : Type ?u.65976
M₃ : Type ?u.65979
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
⊢ ∀ (x : { x // x ∈ p ⊔ p' } ⧸ comap (Submodule.subtype (p ⊔ p')) p'), x ∈ range (subToSupQuotient p p')

tactic: rcases mem_sup.1 hx with ⟨y, hy, z, hz, rfl⟩
state_before: case mk.mk
R : Type u_1
M : Type u_2
M₂ : Type ?u.65976
M₃ : Type ?u.65979
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
x✝ : { x // x ∈ p ⊔ p' } ⧸ comap (Submodule.subtype (p ⊔ p')) p'
x : M
hx : x ∈ p ⊔ p'
⊢ Quot.mk Setoid.r { val := x, property := hx } ∈ range (subToSupQuotient p p')

tactic: use ⟨y, hy⟩
state_before: case mk.mk.intro.intro.intro.intro
R : Type u_1
M : Type u_2
M₂ : Type ?u.65976
M₃ : Type ?u.65979
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
x✝ : { x // x ∈ p ⊔ p' } ⧸ comap (Submodule.subtype (p ⊔ p')) p'
y : M
hy : y ∈ p
z : M
hz : z ∈ p'
hx : y + z ∈ p ⊔ p'
⊢ Quot.mk Setoid.r { val := y + z, property := hx } ∈ range (subToSupQuotient p p')

tactic: apply (Submodule.Quotient.eq _).2
state_before: case mk.mk.intro.intro.intro.intro
R : Type u_1
M : Type u_2
M₂ : Type ?u.65976
M₃ : Type ?u.65979
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
x✝ : { x // x ∈ p ⊔ p' } ⧸ comap (Submodule.subtype (p ⊔ p')) p'
y : M
hy : y ∈ p
z : M
hz : z ∈ p'
hx : y + z ∈ p ⊔ p'
⊢ ↑(subToSupQuotient p p') { val := y, property := hy } = Quot.mk Setoid.r { val := y + z, property := hx }

tactic: simp only [mem_comap, map_sub, coeSubtype, coe_ofLe, sub_add_cancel', neg_mem_iff, hz]
state_before: case mk.mk.intro.intro.intro.intro
R : Type u_1
M : Type u_2
M₂ : Type ?u.65976
M₃ : Type ?u.65979
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
x✝ : { x // x ∈ p ⊔ p' } ⧸ comap (Submodule.subtype (p ⊔ p')) p'
y : M
hy : y ∈ p
z : M
hz : z ∈ p'
hx : y + z ∈ p ⊔ p'
⊢ ↑(ofLe (_ : p ≤ p ⊔ p')) { val := y, property := hy } - { val := y + z, property := hx } ∈
    comap (Submodule.subtype (p ⊔ p')) p'
Theorem: compare_ge_iff_ge
File: Mathlib/Init/Algebra/Order.lean

tactic: cases h : compare a b <;> simp only []
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b ≠ Ordering.lt ↔ a ≥ b

tactic: exact false_iff_iff.2 <| (lt_iff_not_ge a b).1 <| compare_lt_iff_lt.1 h
state_before: case lt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.lt
⊢ False ↔ a ≥ b

tactic: exact true_iff_iff.2 <| le_of_lt <| compare_gt_iff_gt.1 h
state_before: case gt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.gt
⊢ True ↔ a ≥ b
Theorem: CategoryTheory.GrothendieckTopology.isClosed_pullback
File: Mathlib/CategoryTheory/Sites/Closed.lean

tactic: rwa [J₁.covers_iff, Sieve.pullback_comp]
state_before: C : Type u
inst✝ : Category C
J₁ J₂ : GrothendieckTopology C
X Y : C
f : Y ⟶ X
S : Sieve X
hS : IsClosed J₁ S
Z : C
g : Z ⟶ Y
hg : Covers J₁ (Sieve.pullback f S) g
⊢ Covers J₁ S (g ≫ f)
Theorem: Tropical.add_eq_right
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: simpa using h
state_before: R : Type u
inst✝ : LinearOrder R
x y : Tropical R
h : y ≤ x
⊢ untrop (x + y) = untrop y
Theorem: Real.Angle.sin_sub_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ sin (θ - ↑(π / 2)) = -cos θ

tactic: exact Real.sin_sub_pi_div_two _
state_before: case h
x✝ : ℝ
⊢ sin (↑x✝ - ↑(π / 2)) = -cos ↑x✝
Theorem: StrictConvexSpace.ofNormComboNeOne
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: refine' StrictConvexSpace.ofStrictConvexClosedUnitBall ℝ ((convex_closedBall _ _).strictConvex _)
state_before: 𝕜 : Type ?u.22613
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ∃ a b, 0 ≤ a ∧ 0 ≤ b ∧ a + b = 1 ∧ ‖a • x + b • y‖ ≠ 1
⊢ StrictConvexSpace ℝ E

tactic: simp only [interior_closedBall _ one_ne_zero, closedBall_diff_ball, Set.Pairwise,
  frontier_closedBall _ one_ne_zero, mem_sphere_zero_iff_norm]
state_before: 𝕜 : Type ?u.22613
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ∃ a b, 0 ≤ a ∧ 0 ≤ b ∧ a + b = 1 ∧ ‖a • x + b • y‖ ≠ 1
⊢ Set.Pairwise (closedBall 0 1 \ interior (closedBall 0 1)) fun x y =>
    Set.Nonempty ([x-[ℝ]y] \ frontier (closedBall 0 1))

tactic: intro x hx y hy hne
state_before: 𝕜 : Type ?u.22613
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ∃ a b, 0 ≤ a ∧ 0 ≤ b ∧ a + b = 1 ∧ ‖a • x + b • y‖ ≠ 1
⊢ ∀ ⦃x : E⦄, ‖x‖ = 1 → ∀ ⦃y : E⦄, ‖y‖ = 1 → x ≠ y → Set.Nonempty ([x-[ℝ]y] \ sphere 0 1)

tactic: rcases h x y hx hy hne with ⟨a, b, ha, hb, hab, hne'⟩
state_before: 𝕜 : Type ?u.22613
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ∃ a b, 0 ≤ a ∧ 0 ≤ b ∧ a + b = 1 ∧ ‖a • x + b • y‖ ≠ 1
x : E
hx : ‖x‖ = 1
y : E
hy : ‖y‖ = 1
hne : x ≠ y
⊢ Set.Nonempty ([x-[ℝ]y] \ sphere 0 1)

tactic: exact ⟨_, ⟨a, b, ha, hb, hab, rfl⟩, mt mem_sphere_zero_iff_norm.1 hne'⟩
state_before: case intro.intro.intro.intro.intro
𝕜 : Type ?u.22613
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ∃ a b, 0 ≤ a ∧ 0 ≤ b ∧ a + b = 1 ∧ ‖a • x + b • y‖ ≠ 1
x : E
hx : ‖x‖ = 1
y : E
hy : ‖y‖ = 1
hne : x ≠ y
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
hne' : ‖a • x + b • y‖ ≠ 1
⊢ Set.Nonempty ([x-[ℝ]y] \ sphere 0 1)
Theorem: LocalEquiv.refl_restr_target
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: change univ ∩ id ⁻¹' s = s
state_before: α : Type u_1
β : Type ?u.41041
γ : Type ?u.41044
δ : Type ?u.41047
e : LocalEquiv α β
e' : LocalEquiv β γ
s : Set α
⊢ (LocalEquiv.restr (LocalEquiv.refl α) s).target = s

tactic: simp
state_before: α : Type u_1
β : Type ?u.41041
γ : Type ?u.41044
δ : Type ?u.41047
e : LocalEquiv α β
e' : LocalEquiv β γ
s : Set α
⊢ univ ∩ id ⁻¹' s = s
Theorem: Nat.Primrec'.sub
File: Mathlib/Computability/Primrec.lean

tactic: suffices
state_before: ⊢ Primrec' fun v => Vector.head v - Vector.head (Vector.tail v)

tactic: simpa using comp₂ (fun a b => b - a) this (tail head) head
state_before: this : ?m.385414
⊢ Primrec' fun v => Vector.head v - Vector.head (Vector.tail v)

case this

⊢ ?m.385414

tactic: refine' (prec head (pred.comp₁ _ (tail head))).of_eq fun v => _
state_before: case this

⊢ Primrec' fun v => (fun a b => b - a) (Vector.head v) (Vector.head (Vector.tail v))

tactic: simp
state_before: case this
v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec (Vector.head (Vector.tail v)) (fun y IH => Nat.pred (Vector.head (Vector.tail (y ::ᵥ IH ::ᵥ Vector.tail v))))
      (Vector.head v) =
    (fun a b => b - a) (Vector.head v) (Vector.head (Vector.tail v))

tactic: induction v.head <;> simp [*, Nat.sub_succ]
state_before: case this
v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec (Vector.head (Vector.tail v)) (fun y IH => Nat.pred IH) (Vector.head v) =
    Vector.head (Vector.tail v) - Vector.head v
Theorem: Filter.tendsto_const_mul_atTop_of_neg
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa only [neg_mul, tendsto_neg_atBot_iff] using tendsto_const_mul_atBot_of_pos (neg_pos.2 hr)
state_before: ι : Type ?u.228338
ι' : Type ?u.228341
α : Type u_1
β : Type u_2
γ : Type ?u.228350
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : r < 0
⊢ Tendsto (fun x => r * f x) l atTop ↔ Tendsto f l atBot