tasksource/leandojo huggingface dataset:
Theorem: ENNReal.iSup_add_iSup_le
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp_rw [iSup_add, add_iSup]
state_before: α : Type ?u.138674
β : Type ?u.138677
γ : Type ?u.138680
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
ι' : Sort u_2
inst✝¹ : Nonempty ι
inst✝ : Nonempty ι'
f : ι → ℝ≥0∞
g : ι' → ℝ≥0∞
a : ℝ≥0∞
h : ∀ (i : ι) (j : ι'), f i + g j ≤ a
⊢ iSup f + iSup g ≤ a

tactic: exact iSup₂_le h
state_before: α : Type ?u.138674
β : Type ?u.138677
γ : Type ?u.138680
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
ι' : Sort u_2
inst✝¹ : Nonempty ι
inst✝ : Nonempty ι'
f : ι → ℝ≥0∞
g : ι' → ℝ≥0∞
a : ℝ≥0∞
h : ∀ (i : ι) (j : ι'), f i + g j ≤ a
⊢ (⨆ (b : ι) (b_1 : ι'), f b + g b_1) ≤ a
Theorem: Filter.rtendsto_iff_le_rcomap
File: Mathlib/Order/Filter/Partial.lean

tactic: rw [rtendsto_def]
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ RTendsto r l₁ l₂ ↔ l₁ ≤ rcomap r l₂

tactic: simp_rw [←l₂.mem_sets]
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ (∀ (s : Set β), s ∈ l₂ → Rel.core r s ∈ l₁) ↔ l₁ ≤ rcomap r l₂

tactic: simp [Filter.le_def, rcomap, Rel.mem_image]
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ (∀ (s : Set β), s ∈ l₂.sets → Rel.core r s ∈ l₁) ↔ l₁ ≤ rcomap r l₂

tactic: constructor
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ (∀ (s : Set β), s ∈ l₂ → Rel.core r s ∈ l₁) ↔ ∀ (x : Set α) (x_1 : Set β), x_1 ∈ l₂ → Rel.core r x_1 ⊆ x → x ∈ l₁

tactic: exact fun h s t tl₂ => mem_of_superset (h t tl₂)
state_before: case mp
α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ (∀ (s : Set β), s ∈ l₂ → Rel.core r s ∈ l₁) → ∀ (x : Set α) (x_1 : Set β), x_1 ∈ l₂ → Rel.core r x_1 ⊆ x → x ∈ l₁

tactic: exact fun h t tl₂ => h _ t tl₂ Set.Subset.rfl
state_before: case mpr
α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ (∀ (x : Set α) (x_1 : Set β), x_1 ∈ l₂ → Rel.core r x_1 ⊆ x → x ∈ l₁) → ∀ (s : Set β), s ∈ l₂ → Rel.core r s ∈ l₁
Theorem: SimpleGraph.Walk.toSubgraph_cons_nil_eq_subgraphOfAdj
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
h : Adj G u v
⊢ Walk.toSubgraph (cons h nil) = subgraphOfAdj G h
Theorem: OreLocalization.add_comm
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: induction x using OreLocalization.ind
state_before: R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
x y : OreLocalization R S
⊢ x + y = y + x

tactic: induction y using OreLocalization.ind
state_before: case c
R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
y : OreLocalization R S
r✝ : R
s✝ : { x // x ∈ S }
⊢ r✝ /ₒ s✝ + y = y + r✝ /ₒ s✝

tactic: change add' _ _ (_ /ₒ _) = _
state_before: case c.c
R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
r✝¹ : R
s✝¹ : { x // x ∈ S }
r✝ : R
s✝ : { x // x ∈ S }
⊢ r✝¹ /ₒ s✝¹ + r✝ /ₒ s✝ = r✝ /ₒ s✝ + r✝¹ /ₒ s✝¹

tactic: apply add'_comm
state_before: case c.c
R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
r✝¹ : R
s✝¹ : { x // x ∈ S }
r✝ : R
s✝ : { x // x ∈ S }
⊢ OreLocalization.add' (r✝, s✝).fst (r✝, s✝).snd (r✝¹ /ₒ s✝¹) = r✝ /ₒ s✝ + r✝¹ /ₒ s✝¹
Theorem: one_div_lt_one_div_of_neg_of_lt
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [div_lt_iff_of_neg' hb, ← div_eq_mul_one_div, div_lt_one_of_neg (h.trans hb)]
state_before: ι : Type ?u.178065
α : Type u_1
β : Type ?u.178071
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : b < 0
h : a < b
⊢ 1 / b < 1 / a
Theorem: CategoryTheory.Iso.self_symm_id_assoc
File: Mathlib/CategoryTheory/Iso.lean

tactic: rw [← trans_assoc, self_symm_id, refl_trans]
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α : X ≅ Y
β : X ≅ Z
⊢ α ≪≫ α.symm ≪≫ β = β
Theorem: Set.chainHeight_le_chainHeight_TFAE
File: Mathlib/Order/Height.lean

tactic: tfae_have 1 ↔ 3
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
⊢ TFAE
    [chainHeight s ≤ chainHeight t, ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l = length l',
      ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l ≤ length l']

tactic: tfae_have 2 ↔ 3
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
tfae_1_iff_3 :
  chainHeight s ≤ chainHeight t ↔ ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l ≤ length l'
⊢ TFAE
    [chainHeight s ≤ chainHeight t, ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l = length l',
      ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l ≤ length l']

tactic: tfae_finish
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
tfae_1_iff_3 :
  chainHeight s ≤ chainHeight t ↔ ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l ≤ length l'
tfae_2_iff_3 :
  (∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l = length l') ↔
    ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l ≤ length l'
⊢ TFAE
    [chainHeight s ≤ chainHeight t, ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l = length l',
      ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l ≤ length l']

tactic: convert ← chainHeight_add_le_chainHeight_add s t 0 0 <;> apply add_zero
state_before: case tfae_1_iff_3
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
⊢ chainHeight s ≤ chainHeight t ↔ ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l ≤ length l'

tactic: refine' forall₂_congr fun l hl ↦ _
state_before: case tfae_2_iff_3
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
tfae_1_iff_3 :
  chainHeight s ≤ chainHeight t ↔ ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l ≤ length l'
⊢ (∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l = length l') ↔
    ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l ≤ length l'

tactic: simp_rw [← (le_chainHeight_TFAE t l.length).out 1 2, eq_comm]
state_before: case tfae_2_iff_3
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l✝ : List α
a : α
s : Set α
t : Set β
tfae_1_iff_3 :
  chainHeight s ≤ chainHeight t ↔ ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain t ∧ length l ≤ length l'
l : List α
hl : l ∈ subchain s
⊢ (∃ l', l' ∈ subchain t ∧ length l = length l') ↔ ∃ l', l' ∈ subchain t ∧ length l ≤ length l'
Theorem: AlgebraicTopology.DoldKan.Compatibility.equivalence₂UnitIso_eq
File: Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean

tactic: ext X
state_before: A : Type u_1
A' : Type u_5
B : Type u_4
B' : Type u_6
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
⊢ (equivalence₂ eB hF).unitIso = equivalence₂UnitIso eB hF

tactic: dsimp [equivalence₂]
state_before: case w.w.h
A : Type u_1
A' : Type u_5
B : Type u_4
B' : Type u_6
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
X : A
⊢ (equivalence₂ eB hF).unitIso.hom.app X = (equivalence₂UnitIso eB hF).hom.app X

tactic: simp only [equivalence₂UnitIso_hom_app, equivalence₁UnitIso_eq, equivalence₁UnitIso_hom_app,
    assoc, NatIso.cancel_natIso_hom_left]
state_before: case w.w.h
A : Type u_1
A' : Type u_5
B : Type u_4
B' : Type u_6
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
X : A
⊢ (equivalence₁ hF).unitIso.hom.app X ≫ (equivalence₁ hF).inverse.map (eB.counitIso.inv.app (F.obj X)) =
    (equivalence₂UnitIso eB hF).hom.app X

tactic: rfl
state_before: case w.w.h
A : Type u_1
A' : Type u_5
B : Type u_4
B' : Type u_6
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
X : A
⊢ eA.unitIso.hom.app X ≫
      eA.inverse.map (e'.unitIso.hom.app (eA.functor.obj X)) ≫
        eA.inverse.map (e'.inverse.map (hF.hom.app X)) ≫
          (equivalence₁ hF).inverse.map (eB.counitIso.inv.app (F.obj X)) =
    eA.unitIso.hom.app X ≫
      eA.inverse.map (e'.unitIso.hom.app (eA.functor.obj X)) ≫
        eA.inverse.map (e'.inverse.map (hF.hom.app X)) ≫
          eA.inverse.map (e'.inverse.map (eB.counitIso.inv.app (F.obj X)))
Theorem: Polynomial.IsUnitTrinomial.not_isUnit
File: Mathlib/Data/Polynomial/UnitTrinomial.lean

tactic: obtain ⟨k, m, n, hkm, hmn, u, v, w, rfl⟩ := hp
state_before: p q : ℤ[X]
hp : IsUnitTrinomial p
⊢ ¬IsUnit p

tactic: exact fun h =>
  ne_zero_of_lt hmn
    ((trinomial_natDegree hkm hmn w.ne_zero).symm.trans
      (natDegree_eq_of_degree_eq_some (degree_eq_zero_of_isUnit h)))
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
q : ℤ[X]
k m n : ℕ
hkm : k < m
hmn : m < n
u v w : ℤˣ
⊢ ¬IsUnit (trinomial k m n ↑u ↑v ↑w)
Theorem: IsCompl.inf_left_eq_bot_iff
File: Mathlib/Order/Disjoint.lean

tactic: rw [← le_bot_iff, ← h.le_sup_right_iff_inf_left_le, bot_sup_eq]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : BoundedOrder α
a b x y z : α
h : IsCompl y z
⊢ x ⊓ y = ⊥ ↔ x ≤ z
Theorem: Wbtw.trans_sbtw_left
File: Mathlib/Analysis/Convex/Between.lean

tactic: refine' ⟨h₁.trans_left h₂.wbtw, h₂.ne_left, _⟩
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.288204
P : Type u_3
P' : Type ?u.288210
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y z : P
h₁ : Wbtw R w y z
h₂ : Sbtw R w x y
⊢ Sbtw R w x z

tactic: rintro rfl
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.288204
P : Type u_3
P' : Type ?u.288210
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y z : P
h₁ : Wbtw R w y z
h₂ : Sbtw R w x y
⊢ x ≠ z

tactic: exact h₂.right_ne ((wbtw_swap_right_iff R w).1 ⟨h₁, h₂.wbtw⟩)
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.288204
P : Type u_3
P' : Type ?u.288210
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y : P
h₂ : Sbtw R w x y
h₁ : Wbtw R w y x
⊢ False
Theorem: Rat.cast_neg
File: Mathlib/Data/Rat/Cast.lean

tactic: simpa only [cast_def] using
  show (↑(-n) / d : α) = -(n / d) by
    rw [div_eq_mul_inv, div_eq_mul_inv, Int.cast_neg, neg_mul_eq_neg_mul]
state_before: F : Type ?u.19834
ι : Type ?u.19837
α : Type u_1
β : Type ?u.19843
inst✝ : DivisionRing α
n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (Int.natAbs n) d
⊢ ↑(-mk' n d) = -↑(mk' n d)

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, Int.cast_neg, neg_mul_eq_neg_mul]
state_before: F : Type ?u.19834
ι : Type ?u.19837
α : Type u_1
β : Type ?u.19843
inst✝ : DivisionRing α
n : ℤ
d : ℕ
h : d ≠ 0
c : Nat.coprime (Int.natAbs n) d
⊢ ↑(-n) / ↑d = -(↑n / ↑d)
Theorem: Finset.erase_image_subset_image_erase
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [subset_iff, and_imp, exists_prop, mem_image, exists_imp, mem_erase]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.90806
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
s : Finset α
a : α
⊢ erase (image f s) (f a) ⊆ image f (erase s a)

tactic: rintro b hb x hx rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.90806
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
s : Finset α
a : α
⊢ ∀ ⦃x : β⦄, x ≠ f a → ∀ (x_1 : α), x_1 ∈ s → f x_1 = x → ∃ a_4, (a_4 ≠ a ∧ a_4 ∈ s) ∧ f a_4 = x

tactic: exact ⟨_, ⟨ne_of_apply_ne f hb, hx⟩, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.90806
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
s : Finset α
a x : α
hx : x ∈ s
hb : f x ≠ f a
⊢ ∃ a_1, (a_1 ≠ a ∧ a_1 ∈ s) ∧ f a_1 = f x
Theorem: CochainComplex.mkHom_f_succ_succ
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: dsimp [mkHom, mkHomAux]
state_before: ι : Type ?u.344304
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
P Q : CochainComplex V ℕ
zero : HomologicalComplex.X P 0 ⟶ HomologicalComplex.X Q 0
one : HomologicalComplex.X P 1 ⟶ HomologicalComplex.X Q 1
one_zero_comm : zero ≫ HomologicalComplex.d Q 0 1 = HomologicalComplex.d P 0 1 ≫ one
succ :
  (n : ℕ) →
    (p :
        (f : HomologicalComplex.X P n ⟶ HomologicalComplex.X Q n) ×'
          (f' : HomologicalComplex.X P (n + 1) ⟶ HomologicalComplex.X Q (n + 1)) ×'
            f ≫ HomologicalComplex.d Q n (n + 1) = HomologicalComplex.d P n (n + 1) ≫ f') →
      (f'' : HomologicalComplex.X P (n + 2) ⟶ HomologicalComplex.X Q (n + 2)) ×'
        p.snd.fst ≫ HomologicalComplex.d Q (n + 1) (n + 2) = HomologicalComplex.d P (n + 1) (n + 2) ≫ f''
n : ℕ
⊢ HomologicalComplex.Hom.f (mkHom P Q zero one one_zero_comm succ) (n + 2) =
    (succ n
        { fst := HomologicalComplex.Hom.f (mkHom P Q zero one one_zero_comm succ) n,
          snd :=
            { fst := HomologicalComplex.Hom.f (mkHom P Q zero one one_zero_comm succ) (n + 1),
              snd :=
                (_ :
                  HomologicalComplex.Hom.f (mkHom P Q zero one one_zero_comm succ) n ≫
                      HomologicalComplex.d Q n (n + 1) =
                    HomologicalComplex.d P n (n + 1) ≫
                      HomologicalComplex.Hom.f (mkHom P Q zero one one_zero_comm succ) (n + 1)) } }).fst

tactic: induction n <;> congr
state_before: ι : Type ?u.344304
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
P Q : CochainComplex V ℕ
zero : HomologicalComplex.X P 0 ⟶ HomologicalComplex.X Q 0
one : HomologicalComplex.X P 1 ⟶ HomologicalComplex.X Q 1
one_zero_comm : zero ≫ HomologicalComplex.d Q 0 1 = HomologicalComplex.d P 0 1 ≫ one
succ :
  (n : ℕ) →
    (p :
        (f : HomologicalComplex.X P n ⟶ HomologicalComplex.X Q n) ×'
          (f' : HomologicalComplex.X P (n + 1) ⟶ HomologicalComplex.X Q (n + 1)) ×'
            f ≫ HomologicalComplex.d Q n (n + 1) = HomologicalComplex.d P n (n + 1) ≫ f') →
      (f'' : HomologicalComplex.X P (n + 2) ⟶ HomologicalComplex.X Q (n + 2)) ×'
        p.snd.fst ≫ HomologicalComplex.d Q (n + 1) (n + 2) = HomologicalComplex.d P (n + 1) (n + 2) ≫ f''
n : ℕ
⊢ (succ (n + 0) (mkHomAux P Q zero one one_zero_comm succ (n + 0))).fst =
    (succ n
        { fst := (mkHomAux P Q zero one one_zero_comm succ n).fst,
          snd :=
            { fst := (mkHomAux P Q zero one one_zero_comm succ (n + 0)).snd.fst,
              snd :=
                (_ :
                  HomologicalComplex.Hom.f
                        (HomologicalComplex.Hom.mk fun n => (mkHomAux P Q zero one one_zero_comm succ n).fst) n ≫
                      HomologicalComplex.d Q n (n + 1) =
                    HomologicalComplex.d P n (n + 1) ≫
                      HomologicalComplex.Hom.f
                        (HomologicalComplex.Hom.mk fun n => (mkHomAux P Q zero one one_zero_comm succ n).fst)
                        (n + 1)) } }).fst
Theorem: Filter.limsup_congr
File: Mathlib/Order/LiminfLimsup.lean

tactic: rw [limsup_eq]
state_before: α✝ : Type ?u.79050
β : Type u_2
γ : Type ?u.79056
ι : Type ?u.79059
inst✝¹ : ConditionallyCompleteLattice α✝
α : Type u_1
inst✝ : ConditionallyCompleteLattice β
f : Filter α
u v : α → β
h : ∀ᶠ (a : α) in f, u a = v a
⊢ limsup u f = limsup v f

tactic: congr with b
state_before: α✝ : Type ?u.79050
β : Type u_2
γ : Type ?u.79056
ι : Type ?u.79059
inst✝¹ : ConditionallyCompleteLattice α✝
α : Type u_1
inst✝ : ConditionallyCompleteLattice β
f : Filter α
u v : α → β
h : ∀ᶠ (a : α) in f, u a = v a
⊢ sInf {a | ∀ᶠ (n : α) in f, u n ≤ a} = limsup v f

tactic: exact eventually_congr (h.mono fun x hx => by simp [hx])
state_before: case e_a.h
α✝ : Type ?u.79050
β : Type u_2
γ : Type ?u.79056
ι : Type ?u.79059
inst✝¹ : ConditionallyCompleteLattice α✝
α : Type u_1
inst✝ : ConditionallyCompleteLattice β
f : Filter α
u v : α → β
h : ∀ᶠ (a : α) in f, u a = v a
b : β
⊢ b ∈ {a | ∀ᶠ (n : α) in f, u n ≤ a} ↔ b ∈ {a | ∀ᶠ (n : β) in map v f, n ≤ a}

tactic: simp [hx]
state_before: α✝ : Type ?u.79050
β : Type u_2
γ : Type ?u.79056
ι : Type ?u.79059
inst✝¹ : ConditionallyCompleteLattice α✝
α : Type u_1
inst✝ : ConditionallyCompleteLattice β
f : Filter α
u v : α → β
h : ∀ᶠ (a : α) in f, u a = v a
b : β
x : α
hx : u x = v x
⊢ u x ≤ b ↔ v x ∈ {x | (fun n => n ≤ b) x}
Theorem: List.mem_filterMap
File: Std/Data/List/Lemmas.lean

tactic: induction l <;> simp
state_before: α : Type u_1
β : Type u_2
f : α → Option β
l : List α
b : β
⊢ b ∈ filterMap f l ↔ ∃ a, a ∈ l ∧ f a = some b

tactic: split <;> simp [*, eq_comm]
state_before: case cons
α : Type u_1
β : Type u_2
f : α → Option β
b : β
head✝ : α
tail✝ : List α
tail_ih✝ : b ∈ filterMap f tail✝ ↔ ∃ a, a ∈ tail✝ ∧ f a = some b
⊢ (b ∈
      match f head✝ with
      | none => filterMap f tail✝
      | some b => b :: filterMap f tail✝) ↔
    f head✝ = some b ∨ ∃ a, a ∈ tail✝ ∧ f a = some b
Theorem: collinear_insert_insert_insert_left_of_mem_affineSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: refine' (collinear_insert_insert_insert_of_mem_affineSpan_pair h₁ h₂ h₃).subset _
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.331367
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ p₅ : P
h₁ : p₁ ∈ affineSpan k {p₄, p₅}
h₂ : p₂ ∈ affineSpan k {p₄, p₅}
h₃ : p₃ ∈ affineSpan k {p₄, p₅}
⊢ Collinear k {p₁, p₂, p₃, p₄}

tactic: repeat apply Set.insert_subset_insert
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.331367
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ p₅ : P
h₁ : p₁ ∈ affineSpan k {p₄, p₅}
h₂ : p₂ ∈ affineSpan k {p₄, p₅}
h₃ : p₃ ∈ affineSpan k {p₄, p₅}
⊢ {p₁, p₂, p₃, p₄} ⊆ {p₁, p₂, p₃, p₄, p₅}

tactic: simp
state_before: case h.h.h
k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.331367
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ p₅ : P
h₁ : p₁ ∈ affineSpan k {p₄, p₅}
h₂ : p₂ ∈ affineSpan k {p₄, p₅}
h₃ : p₃ ∈ affineSpan k {p₄, p₅}
⊢ {p₄} ⊆ {p₄, p₅}

tactic: apply Set.insert_subset_insert
state_before: case h.h.h
k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.331367
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ p₅ : P
h₁ : p₁ ∈ affineSpan k {p₄, p₅}
h₂ : p₂ ∈ affineSpan k {p₄, p₅}
h₃ : p₃ ∈ affineSpan k {p₄, p₅}
⊢ {p₄} ⊆ {p₄, p₅}
Theorem: Units.inv_mul_cancel_right
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [mul_assoc, inv_mul, mul_one]
state_before: α : Type u
inst✝ : Monoid α
a✝ b✝ c u : αˣ
a : α
b : αˣ
⊢ a * ↑b⁻¹ * ↑b = a
Theorem: Fin.init_update_last
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: ext j
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (↑castSucc i)
i : Fin n
y : α (↑castSucc i)
z : α (last n)
⊢ init (update q (last n) z) = init q

tactic: simp [init, ne_of_lt, castSucc_lt_last]
state_before: case h
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (↑castSucc i)
i : Fin n
y : α (↑castSucc i)
z : α (last n)
j : Fin n
⊢ init (update q (last n) z) j = init q j
Theorem: exists_open_between_and_isCompact_closure
File: Mathlib/Topology/Separation.lean

tactic: rcases exists_compact_between hK hU hKU with ⟨V, hV, hKV, hVU⟩
state_before: α : Type u
β : Type v
inst✝⁴ : TopologicalSpace α
γ : Type ?u.141701
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : LocallyCompactSpace α
inst✝ : T2Space α
K U : Set α
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
⊢ ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U ∧ IsCompact (closure V)

tactic: exact
  ⟨interior V, isOpen_interior, hKV, (closure_minimal interior_subset hV.isClosed).trans hVU,
    isCompact_closure_of_subset_compact hV interior_subset⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
inst✝⁴ : TopologicalSpace α
γ : Type ?u.141701
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : LocallyCompactSpace α
inst✝ : T2Space α
K U : Set α
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
V : Set α
hV : IsCompact V
hKV : K ⊆ interior V
hVU : V ⊆ U
⊢ ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U ∧ IsCompact (closure V)
Theorem: mul_div_cancel_left_of_imp
File: Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean

tactic: rw [mul_comm, mul_div_cancel_of_imp h]
state_before: α : Type ?u.10733
M₀ : Type ?u.10736
G₀ : Type u_1
M₀' : Type ?u.10742
G₀' : Type ?u.10745
F : Type ?u.10748
F' : Type ?u.10751
inst✝¹ : MonoidWithZero M₀
inst✝ : CommGroupWithZero G₀
a✝ b✝ c d a b : G₀
h : a = 0 → b = 0
⊢ a * b / a = b
Theorem: posMulReflectLT_iff_mulPosReflectLT
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simp only [PosMulReflectLT, MulPosReflectLT, mul_comm]
state_before: α : Type u_1
a b c d : α
inst✝² : CommSemigroup α
inst✝¹ : Zero α
inst✝ : Preorder α
⊢ PosMulReflectLT α ↔ MulPosReflectLT α
Theorem: norm_add_mul_self_real
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: have h := @norm_add_mul_self ℝ _ _ _ _ x y
state_before: 𝕜 : Type ?u.2403269
E : Type ?u.2403272
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * inner x y + ‖y‖ * ‖y‖

tactic: simpa using h
state_before: 𝕜 : Type ?u.2403269
E : Type ?u.2403272
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
h : ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * ↑re (inner x y) + ‖y‖ * ‖y‖
⊢ ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * inner x y + ‖y‖ * ‖y‖
Theorem: List.count_filter
File: Mathlib/Data/List/Count.lean

tactic: rw [count, countp_filter]
state_before: α : Type u_1
l : List α
inst✝ : DecidableEq α
p : α → Bool
a : α
h : p a = true
⊢ count a (filter p l) = count a l

tactic: congr
state_before: α : Type u_1
l : List α
inst✝ : DecidableEq α
p : α → Bool
a : α
h : p a = true
⊢ countp (fun a_1 => decide ((a_1 == a) = true ∧ p a_1 = true)) l = countp (fun x => x == a) l

tactic: funext b
state_before: case e_p
α : Type u_1
l : List α
inst✝ : DecidableEq α
p : α → Bool
a : α
h : p a = true
⊢ (fun a_1 => decide ((a_1 == a) = true ∧ p a_1 = true)) = fun x => x == a

tactic: rw [Bool.beq_eq_decide_eq]
state_before: case e_p.h
α : Type u_1
l : List α
inst✝ : DecidableEq α
p : α → Bool
a : α
h : p a = true
b : α
⊢ decide ((b == a) = true ∧ p b = true) = (b == a)

tactic: by_cases hb : b = a
state_before: case e_p.h
α : Type u_1
l : List α
inst✝ : DecidableEq α
p : α → Bool
a : α
h : p a = true
b : α
⊢ decide (decide (b = a) = true ∧ p b = true) = decide (b = a)

tactic: simp [hb, h]
state_before: case pos
α : Type u_1
l : List α
inst✝ : DecidableEq α
p : α → Bool
a : α
h : p a = true
b : α
hb : b = a
⊢ decide (decide (b = a) = true ∧ p b = true) = decide (b = a)

tactic: simp [hb]
state_before: case neg
α : Type u_1
l : List α
inst✝ : DecidableEq α
p : α → Bool
a : α
h : p a = true
b : α
hb : ¬b = a
⊢ decide (decide (b = a) = true ∧ p b = true) = decide (b = a)