1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Inducing.mapClusterPt_iff
File: Mathlib/Topology/Maps.lean

tactic: delta MapClusterPt ClusterPt
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Inducing f
x : X
l : Filter X
⊢ MapClusterPt (f x) l f ↔ ClusterPt x l
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Inducing f
x : X
l : Filter X
⊢ (𝓝 (f x) ⊓ map f l).NeBot ↔ (𝓝 x ⊓ l).NeBot

tactic: rw [← Filter.push_pull', ← hf.nhds_eq_comap, map_neBot_iff]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hf : Inducing f
x : X
l : Filter X
⊢ (𝓝 (f x) ⊓ map f l).NeBot ↔ (𝓝 x ⊓ l).NeBot
state_after: no goals
Theorem: PFunctor.M.ext'
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: cases x
state_before: F : PFunctor.{u}
x y : F.M
H : ∀ (i : ℕ), x.approx i = y.approx i
⊢ x = y
state_after: case mk
F : PFunctor.{u}
y : F.M
approx✝ : (n : ℕ) → CofixA F n
consistent✝ : AllAgree approx✝
H : ∀ (i : ℕ), { approx := approx✝, consistent := consistent✝ }.approx i = y.approx i
⊢ { approx := approx✝, consistent := consistent✝ } = y

tactic: cases y
state_before: case mk
F : PFunctor.{u}
y : F.M
approx✝ : (n : ℕ) → CofixA F n
consistent✝ : AllAgree approx✝
H : ∀ (i : ℕ), { approx := approx✝, consistent := consistent✝ }.approx i = y.approx i
⊢ { approx := approx✝, consistent := consistent✝ } = y
state_after: case mk.mk
F : PFunctor.{u}
approx✝¹ : (n : ℕ) → CofixA F n
consistent✝¹ : AllAgree approx✝¹
approx✝ : (n : ℕ) → CofixA F n
consistent✝ : AllAgree approx✝
H :
  ∀ (i : ℕ),
    { approx := approx✝¹, consistent := consistent✝¹ }.approx i =
      { approx := approx✝, consistent := consistent✝ }.approx i
⊢ { approx := approx✝¹, consistent := consistent✝¹ } = { approx := approx✝, consistent := consistent✝ }

tactic: congr with n
state_before: case mk.mk
F : PFunctor.{u}
approx✝¹ : (n : ℕ) → CofixA F n
consistent✝¹ : AllAgree approx✝¹
approx✝ : (n : ℕ) → CofixA F n
consistent✝ : AllAgree approx✝
H :
  ∀ (i : ℕ),
    { approx := approx✝¹, consistent := consistent✝¹ }.approx i =
      { approx := approx✝, consistent := consistent✝ }.approx i
⊢ { approx := approx✝¹, consistent := consistent✝¹ } = { approx := approx✝, consistent := consistent✝ }
state_after: case mk.mk.e_approx.h
F : PFunctor.{u}
approx✝¹ : (n : ℕ) → CofixA F n
consistent✝¹ : AllAgree approx✝¹
approx✝ : (n : ℕ) → CofixA F n
consistent✝ : AllAgree approx✝
H :
  ∀ (i : ℕ),
    { approx := approx✝¹, consistent := consistent✝¹ }.approx i =
      { approx := approx✝, consistent := consistent✝ }.approx i
n : ℕ
⊢ approx✝¹ n = approx✝ n

tactic: apply H
state_before: case mk.mk.e_approx.h
F : PFunctor.{u}
approx✝¹ : (n : ℕ) → CofixA F n
consistent✝¹ : AllAgree approx✝¹
approx✝ : (n : ℕ) → CofixA F n
consistent✝ : AllAgree approx✝
H :
  ∀ (i : ℕ),
    { approx := approx✝¹, consistent := consistent✝¹ }.approx i =
      { approx := approx✝, consistent := consistent✝ }.approx i
n : ℕ
⊢ approx✝¹ n = approx✝ n
state_after: no goals
Theorem: himp_bihimp
File: Mathlib/Order/SymmDiff.lean

tactic: rw [bihimp, himp_inf_distrib, himp_himp, himp_himp]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ a ⇨ b ⇔ c = (a ⊓ c ⇨ b) ⊓ (a ⊓ b ⇨ c)
state_after: no goals
Theorem: List.reverse_concat'
File: Mathlib/Data/List/Basic.lean

tactic: rw [reverse_append]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
a : α
⊢ (l ++ [a]).reverse = a :: l.reverse
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
a : α
⊢ [a].reverse ++ l.reverse = a :: l.reverse

tactic: rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
a : α
⊢ [a].reverse ++ l.reverse = a :: l.reverse
state_after: no goals
Theorem: CategoryTheory.Limits.colimitIsoColimitCurryCompColim_ι_hom
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: rw [← cancel_mono (colimitIsoColimitCurryCompColim G).inv]
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit G
inst✝ : HasColimit (curry.obj G ⋙ colim)
j : J
k : K
⊢ colimit.ι G (j, k) ≫ (colimitIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j
state_after: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit G
inst✝ : HasColimit (curry.obj G ⋙ colim)
j : J
k : K
⊢ (colimit.ι G (j, k) ≫ (colimitIsoColimitCurryCompColim G).hom) ≫ (colimitIsoColimitCurryCompColim G).inv =
    (colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j) ≫ (colimitIsoColimitCurryCompColim G).inv

tactic: simp
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝² : HasColimitsOfShape K C
inst✝¹ : HasColimit G
inst✝ : HasColimit (curry.obj G ⋙ colim)
j : J
k : K
⊢ (colimit.ι G (j, k) ≫ (colimitIsoColimitCurryCompColim G).hom) ≫ (colimitIsoColimitCurryCompColim G).inv =
    (colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j) ≫ (colimitIsoColimitCurryCompColim G).inv
state_after: no goals
Theorem: IsUnit.div_div_cancel
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [div_div_eq_mul_div, h.mul_div_cancel_left]
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionCommMonoid α
a b c d : α
h : IsUnit a
⊢ a / (a / b) = b
state_after: no goals
Theorem: nhds_left_sup_nhds_right'
File: Mathlib/Topology/Order/LeftRight.lean

tactic: rw [← nhdsWithin_union, Iic_union_Ioi, nhdsWithin_univ]
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
⊢ 𝓝[≤] a ⊔ 𝓝[>] a = 𝓝 a
state_after: no goals
Theorem: sInf_div
File: Mathlib/Algebra/Order/Pointwise.lean

tactic: simp_rw [div_eq_mul_inv, sInf_mul, sInf_inv]
state_before: α : Type u_1
inst✝³ : CompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s t : Set α
⊢ sInf (s / t) = sInf s / sSup t
state_after: no goals
Theorem: ChainClosure.succ_fixpoint
File: Mathlib/Order/Chain.lean

tactic: induction hc₁ with
| succ hc₁ h => exact (chainClosure_succ_total hc₁ hc₂ h).elim (fun h => h ▸ hc.subset) id
| union _ ih => exact sUnion_subset ih
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc₁ : ChainClosure r c₁
hc₂ : ChainClosure r c₂
hc : SuccChain r c₂ = c₂
⊢ c₁ ⊆ c₂
state_after: no goals

tactic: exact (chainClosure_succ_total hc₁ hc₂ h).elim (fun h => h ▸ hc.subset) id
state_before: case succ
α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc₂ : ChainClosure r c₂
hc : SuccChain r c₂ = c₂
s✝ : Set α
hc₁ : ChainClosure r s✝
h : s✝ ⊆ c₂
⊢ SuccChain r s✝ ⊆ c₂
state_after: no goals

tactic: exact sUnion_subset ih
state_before: case union
α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc₂ : ChainClosure r c₂
hc : SuccChain r c₂ = c₂
s✝ : Set (Set α)
a✝ : ∀ a ∈ s✝, ChainClosure r a
ih : ∀ a ∈ s✝, a ⊆ c₂
⊢ ⋃₀ s✝ ⊆ c₂
state_after: no goals
Theorem: ProbabilityTheory.gaussianReal_map_const_add
File: Mathlib/Probability/Distributions/Gaussian.lean

tactic: simp_rw [add_comm y]
state_before: μ : ℝ
v : ℝ≥0
y : ℝ
⊢ Measure.map (fun x => y + x) (gaussianReal μ v) = gaussianReal (μ + y) v
state_after: μ : ℝ
v : ℝ≥0
y : ℝ
⊢ Measure.map (fun x => x + y) (gaussianReal μ v) = gaussianReal (μ + y) v

tactic: exact gaussianReal_map_add_const y
state_before: μ : ℝ
v : ℝ≥0
y : ℝ
⊢ Measure.map (fun x => x + y) (gaussianReal μ v) = gaussianReal (μ + y) v
state_after: no goals
Theorem: MeasureTheory.measure_inter_add_diff₀
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: refine le_antisymm ?_ (measure_le_inter_add_diff _ _ _)
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t μ
⊢ μ (s ∩ t) + μ (s \ t) = μ s
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t μ
⊢ μ (s ∩ t) + μ (s \ t) ≤ μ s

tactic: rcases exists_measurable_superset μ s with ⟨s', hsub, hs'm, hs'⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t μ
⊢ μ (s ∩ t) + μ (s \ t) ≤ μ s
state_after: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t μ
s' : Set α
hsub : s ⊆ s'
hs'm : MeasurableSet s'
hs' : μ s' = μ s
⊢ μ (s ∩ t) + μ (s \ t) ≤ μ s

tactic: replace hs'm : NullMeasurableSet s' μ := hs'm.nullMeasurableSet
state_before: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t μ
s' : Set α
hsub : s ⊆ s'
hs'm : MeasurableSet s'
hs' : μ s' = μ s
⊢ μ (s ∩ t) + μ (s \ t) ≤ μ s
state_after: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t μ
s' : Set α
hsub : s ⊆ s'
hs' : μ s' = μ s
hs'm : NullMeasurableSet s' μ
⊢ μ (s ∩ t) + μ (s \ t) ≤ μ s

tactic: calc
  μ (s ∩ t) + μ (s \ t) ≤ μ (s' ∩ t) + μ (s' \ t) := by gcongr
  _ = μ (s' ∩ t ∪ s' \ t) :=
    (measure_union₀_aux (hs'm.inter ht) (hs'm.diff ht) <|
        (@disjoint_inf_sdiff _ s' t _).aedisjoint).symm
  _ = μ s' := congr_arg μ (inter_union_diff _ _)
  _ = μ s := hs'
state_before: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t μ
s' : Set α
hsub : s ⊆ s'
hs' : μ s' = μ s
hs'm : NullMeasurableSet s' μ
⊢ μ (s ∩ t) + μ (s \ t) ≤ μ s
state_after: no goals

tactic: gcongr
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t μ
s' : Set α
hsub : s ⊆ s'
hs' : μ s' = μ s
hs'm : NullMeasurableSet s' μ
⊢ μ (s ∩ t) + μ (s \ t) ≤ μ (s' ∩ t) + μ (s' \ t)
state_after: no goals
Theorem: Sum.getLeft?_eq_some_iff
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

tactic: cases x <;> simp only [getLeft?, Option.some.injEq, inl.injEq]
state_before: α✝ : Type u_1
a : α✝
β✝ : Type u_2
x : α✝ ⊕ β✝
⊢ x.getLeft? = some a ↔ x = inl a
state_after: no goals
Theorem: Submodule.map_subtype_range_inclusion
File: Mathlib/Algebra/Module/Submodule/Range.lean

tactic: simp [range_inclusion, map_comap_eq, h]
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝⁷ : Semiring R
inst✝⁶ : Semiring R₂
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M
inst✝² : Module R₂ M₂
p✝ p'✝ : Submodule R M
q : Submodule R₂ M₂
τ₁₂ : R →+* R₂
F : Type u_11
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
p p' : Submodule R M
h : p ≤ p'
⊢ map p'.subtype (range (inclusion h)) = p
state_after: no goals
Theorem: GeneralizedContinuedFraction.coe_of_h_rat_eq
File: Mathlib/Algebra/ContinuedFractions/Computation/TerminatesIffRat.lean

tactic: unfold of IntFractPair.seq1
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
q : ℚ
v_eq_q : v = ↑q
n : ℕ
⊢ ↑(of q).h = (of v).h
state_after: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
q : ℚ
v_eq_q : v = ↑q
n : ℕ
⊢ ↑(match (IntFractPair.of q, Stream'.Seq.tail ⟨IntFractPair.stream q, ⋯⟩) with
        | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).h =
    (match (IntFractPair.of v, Stream'.Seq.tail ⟨IntFractPair.stream v, ⋯⟩) with
      | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).h

tactic: rw [← IntFractPair.coe_of_rat_eq v_eq_q]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
q : ℚ
v_eq_q : v = ↑q
n : ℕ
⊢ ↑(match (IntFractPair.of q, Stream'.Seq.tail ⟨IntFractPair.stream q, ⋯⟩) with
        | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).h =
    (match (IntFractPair.of v, Stream'.Seq.tail ⟨IntFractPair.stream v, ⋯⟩) with
      | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).h
state_after: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
q : ℚ
v_eq_q : v = ↑q
n : ℕ
⊢ ↑(match (IntFractPair.of q, Stream'.Seq.tail ⟨IntFractPair.stream q, ⋯⟩) with
        | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).h =
    (match (IntFractPair.mapFr Rat.cast (IntFractPair.of q), Stream'.Seq.tail ⟨IntFractPair.stream v, ⋯⟩) with
      | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).h

tactic: simp
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
q : ℚ
v_eq_q : v = ↑q
n : ℕ
⊢ ↑(match (IntFractPair.of q, Stream'.Seq.tail ⟨IntFractPair.stream q, ⋯⟩) with
        | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).h =
    (match (IntFractPair.mapFr Rat.cast (IntFractPair.of q), Stream'.Seq.tail ⟨IntFractPair.stream v, ⋯⟩) with
      | (h, s) => { h := ↑h.b, s := Stream'.Seq.map (fun p => { a := 1, b := ↑p.b }) s }).h
state_after: no goals
Theorem: SubfieldClass.nnratCast_mem
File: Mathlib/Algebra/Field/Subfield.lean

tactic: simpa only [NNRat.cast_def] using div_mem (natCast_mem s q.num) (natCast_mem s q.den)
state_before: K : Type u
L : Type v
M : Type w
inst✝³ : DivisionRing K
inst✝² : DivisionRing L
inst✝¹ : DivisionRing M
S : Type u_1
inst✝ : SetLike S K
h : SubfieldClass S K
x : K
s : S
q : ℚ≥0
⊢ ↑q ∈ s
state_after: no goals
Theorem: TrivSqZeroExt.inv_neg
File: Mathlib/Algebra/TrivSqZeroExt.lean

tactic: ext <;> simp [inv_neg]
state_before: R : Type u
M : Type v
inst✝⁴ : DivisionRing R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
x : tsze R M
⊢ (-x)⁻¹ = -x⁻¹
state_after: no goals
Theorem: Function.Injective.hasProd_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Defs.lean

tactic: simp only [HasProd, Tendsto, comp_apply, hg.map_atTop_finset_prod_eq hf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
g : γ → β
hg : Injective g
hf : ∀ x ∉ Set.range g, f x = 1
⊢ HasProd (f ∘ g) a ↔ HasProd f a
state_after: no goals
Theorem: Real.cos_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [cos]
state_before: x y : ℝ
⊢ cos 0 = 1
state_after: no goals
Theorem: FreeMonoid.ofList_join
File: Mathlib/Algebra/FreeMonoid/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
M : Type u_4
inst✝¹ : Monoid M
N : Type u_5
inst✝ : Monoid N
xs : List (List α)
⊢ toList (ofList xs.join) = toList (List.map (⇑ofList) xs).prod
state_after: no goals
Theorem: Set.Nontrivial.infsep_lt_iff
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rw [← not_iff_not]
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : s.Nontrivial
⊢ s.infsep < d ↔ ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ dist x y < d
state_after: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : s.Nontrivial
⊢ ¬s.infsep < d ↔ ¬∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ dist x y < d

tactic: push_neg
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : s.Nontrivial
⊢ ¬s.infsep < d ↔ ¬∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ dist x y < d
state_after: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : s.Nontrivial
⊢ d ≤ s.infsep ↔ ∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ dist x y

tactic: exact hs.le_infsep_iff
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : s.Nontrivial
⊢ d ≤ s.infsep ↔ ∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ dist x y
state_after: no goals
Theorem: CochainComplex.mappingCone.inr_f_snd_v
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

tactic: simp [inr, snd]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p : ℤ
⊢ (inr φ).f p ≫ (snd φ).v p p ⋯ = 𝟙 (G.X p)
state_after: no goals
Theorem: equivShrink_neg
File: Mathlib/Logic/Small/Group.lean

tactic: rw [Equiv.neg_def]
state_before: α : Type u_1
inst✝¹ : Neg α
inst✝ : Small.{u_2, u_1} α
x : α
⊢ (equivShrink α) (-x) = -(equivShrink α) x
state_after: α : Type u_1
inst✝¹ : Neg α
inst✝ : Small.{u_2, u_1} α
x : α
⊢ (equivShrink α) (-x) = (equivShrink α).symm.symm (-(equivShrink α).symm ((equivShrink α) x))

tactic: simp
state_before: α : Type u_1
inst✝¹ : Neg α
inst✝ : Small.{u_2, u_1} α
x : α
⊢ (equivShrink α) (-x) = (equivShrink α).symm.symm (-(equivShrink α).symm ((equivShrink α) x))
state_after: no goals
Theorem: AddLECancellable.lt_tsub_iff_right_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: refine ⟨fun h' => (add_le_of_le_tsub_right_of_le h h'.le).lt_of_ne ?_, hc.lt_tsub_of_add_lt_right⟩
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : c ≤ b
⊢ a < b - c ↔ a + c < b
state_after: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : c ≤ b
h' : a < b - c
⊢ a + c ≠ b

tactic: rintro rfl
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : c ≤ b
h' : a < b - c
⊢ a + c ≠ b
state_after: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c d : α
hc : AddLECancellable c
h : c ≤ a + c
h' : a < a + c - c
⊢ False

tactic: exact h'.ne' hc.add_tsub_cancel_right
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c d : α
hc : AddLECancellable c
h : c ≤ a + c
h' : a < a + c - c
⊢ False
state_after: no goals
Theorem: IsOpenMap.comp
File: Mathlib/Topology/Maps.lean

tactic: rw [image_comp]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hg : IsOpenMap g
hf : IsOpenMap f
s : Set X
hs : IsOpen s
⊢ IsOpen (g ∘ f '' s)
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hg : IsOpenMap g
hf : IsOpenMap f
s : Set X
hs : IsOpen s
⊢ IsOpen (g '' (f '' s))

tactic: exact hg _ (hf _ hs)
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hg : IsOpenMap g
hf : IsOpenMap f
s : Set X
hs : IsOpen s
⊢ IsOpen (g '' (f '' s))
state_after: no goals
Theorem: ADEInequality.admissible_of_one_lt_sumInv_aux
File: Mathlib/NumberTheory/ADEInequality.lean

tactic: obtain ⟨⟨hpq, -⟩, hqr⟩ : (p ≤ q ∧ p ≤ r) ∧ q ≤ r := by simpa using hs
state_before: p q r : ℕ+
hs : List.Sorted (fun x x_1 => x ≤ x_1) [p, q, r]
x✝ : [p, q, r].length = 3
H : 1 < sumInv ↑[p, q, r]
⊢ Admissible ↑[p, q, r]
state_after: case intro.intro
p q r : ℕ+
hs : List.Sorted (fun x x_1 => x ≤ x_1) [p, q, r]
x✝ : [p, q, r].length = 3
H : 1 < sumInv ↑[p, q, r]
hqr : q ≤ r
hpq : p ≤ q
⊢ Admissible ↑[p, q, r]

tactic: exact admissible_of_one_lt_sumInv_aux' hpq hqr H
state_before: case intro.intro
p q r : ℕ+
hs : List.Sorted (fun x x_1 => x ≤ x_1) [p, q, r]
x✝ : [p, q, r].length = 3
H : 1 < sumInv ↑[p, q, r]
hqr : q ≤ r
hpq : p ≤ q
⊢ Admissible ↑[p, q, r]
state_after: no goals

tactic: simpa using hs
state_before: p q r : ℕ+
hs : List.Sorted (fun x x_1 => x ≤ x_1) [p, q, r]
x✝ : [p, q, r].length = 3
H : 1 < sumInv ↑[p, q, r]
⊢ (p ≤ q ∧ p ≤ r) ∧ q ≤ r
state_after: no goals
Theorem: Real.logb_le_iff_le_rpow
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← rpow_le_rpow_left_iff hb, rpow_logb (b_pos hb) (b_ne_one' hb) hx]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
⊢ logb b x ≤ y ↔ x ≤ b ^ y
state_after: no goals
Theorem: Cycle.nontrivial_coe_nodup_iff
File: Mathlib/Data/List/Cycle.lean

tactic: rw [Nontrivial]
state_before: α : Type u_1
l : List α
hl : l.Nodup
⊢ (↑l).Nontrivial ↔ 2 ≤ l.length
state_after: α : Type u_1
l : List α
hl : l.Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑l ∧ y ∈ ↑l) ↔ 2 ≤ l.length

tactic: rcases l with (_ | ⟨hd, _ | ⟨hd', tl⟩⟩)
state_before: α : Type u_1
l : List α
hl : l.Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑l ∧ y ∈ ↑l) ↔ 2 ≤ l.length
state_after: case nil
α : Type u_1
hl : [].Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑[] ∧ y ∈ ↑[]) ↔ 2 ≤ [].length

case cons.nil
α : Type u_1
hd : α
hl : [hd].Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑[hd] ∧ y ∈ ↑[hd]) ↔ 2 ≤ [hd].length

case cons.cons
α : Type u_1
hd hd' : α
tl : List α
hl : (hd :: hd' :: tl).Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑(hd :: hd' :: tl) ∧ y ∈ ↑(hd :: hd' :: tl)) ↔ 2 ≤ (hd :: hd' :: tl).length

tactic: simp
state_before: case nil
α : Type u_1
hl : [].Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑[] ∧ y ∈ ↑[]) ↔ 2 ≤ [].length
state_after: no goals

tactic: simp
state_before: case cons.nil
α : Type u_1
hd : α
hl : [hd].Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑[hd] ∧ y ∈ ↑[hd]) ↔ 2 ≤ [hd].length
state_after: no goals

tactic: simp only [mem_cons, exists_prop, mem_coe_iff, List.length, Ne, Nat.succ_le_succ_iff,
  Nat.zero_le, iff_true_iff]
state_before: case cons.cons
α : Type u_1
hd hd' : α
tl : List α
hl : (hd :: hd' :: tl).Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑(hd :: hd' :: tl) ∧ y ∈ ↑(hd :: hd' :: tl)) ↔ 2 ≤ (hd :: hd' :: tl).length
state_after: case cons.cons
α : Type u_1
hd hd' : α
tl : List α
hl : (hd :: hd' :: tl).Nodup
⊢ ∃ x y, ¬x = y ∧ (x = hd ∨ x = hd' ∨ x ∈ tl) ∧ (y = hd ∨ y = hd' ∨ y ∈ tl)

tactic: refine ⟨hd, hd', ?_, by simp⟩
state_before: case cons.cons
α : Type u_1
hd hd' : α
tl : List α
hl : (hd :: hd' :: tl).Nodup
⊢ ∃ x y, ¬x = y ∧ (x = hd ∨ x = hd' ∨ x ∈ tl) ∧ (y = hd ∨ y = hd' ∨ y ∈ tl)
state_after: case cons.cons
α : Type u_1
hd hd' : α
tl : List α
hl : (hd :: hd' :: tl).Nodup
⊢ ¬hd = hd'

tactic: simp only [not_or, mem_cons, nodup_cons] at hl
state_before: case cons.cons
α : Type u_1
hd hd' : α
tl : List α
hl : (hd :: hd' :: tl).Nodup
⊢ ¬hd = hd'
state_after: case cons.cons
α : Type u_1
hd hd' : α
tl : List α
hl : (¬hd = hd' ∧ hd ∉ tl) ∧ hd' ∉ tl ∧ tl.Nodup
⊢ ¬hd = hd'

tactic: exact hl.left.left
state_before: case cons.cons
α : Type u_1
hd hd' : α
tl : List α
hl : (¬hd = hd' ∧ hd ∉ tl) ∧ hd' ∉ tl ∧ tl.Nodup
⊢ ¬hd = hd'
state_after: no goals

tactic: simp
state_before: α : Type u_1
hd hd' : α
tl : List α
hl : (hd :: hd' :: tl).Nodup
⊢ (hd = hd ∨ hd = hd' ∨ hd ∈ tl) ∧ (hd' = hd ∨ hd' = hd' ∨ hd' ∈ tl)
state_after: no goals