tasksource/leandojo huggingface dataset:
Theorem: Finset.mulEtransformRight.card
File: Mathlib/Combinatorics/Additive/Etransform.lean

tactic: rw [card_smul_finset, two_mul]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Group α
e : α
x : Finset α × Finset α
⊢ Finset.card x.snd + Finset.card (e⁻¹ • x.snd) = 2 * Finset.card x.snd
Theorem: Finset.forall_disjSups_iff
File: Mathlib/Data/Finset/Sups.lean

tactic: simp_rw [mem_disjSups]
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
p : α → Prop
⊢ (∀ (c : α), c ∈ s ○ t → p c) ↔ ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → Disjoint a b → p (a ⊔ b)

tactic: refine' ⟨fun h a ha b hb hab => h _ ⟨_, ha, _, hb, hab, rfl⟩, _⟩
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
p : α → Prop
⊢ (∀ (c : α), (∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ Disjoint a b ∧ a ⊔ b = c) → p c) ↔
    ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → Disjoint a b → p (a ⊔ b)

tactic: rintro h _ ⟨a, ha, b, hb, hab, rfl⟩
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
p : α → Prop
⊢ (∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → Disjoint a b → p (a ⊔ b)) →
    ∀ (c : α), (∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ Disjoint a b ∧ a ⊔ b = c) → p c

tactic: exact h _ ha _ hb hab
state_before: case intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : DecidableEq α
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a✝ b✝ c : α
p : α → Prop
h : ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → Disjoint a b → p (a ⊔ b)
a : α
ha : a ∈ s
b : α
hb : b ∈ t
hab : Disjoint a b
⊢ p (a ⊔ b)
Theorem: TopCat.prodIsoProd_inv_snd
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

tactic: simp [Iso.inv_comp_eq]
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
⊢ (prodIsoProd X Y).inv ≫ prod.snd = prodSnd
Theorem: OpenEmbedding.compatiblePreserving
File: Mathlib/Topology/Sheaves/SheafCondition/Sites.lean

tactic: haveI : Mono f := (TopCat.mono_iff_injective f).mpr hf.inj
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ((forget TopCat).map f)
⊢ CompatiblePreserving (Opens.grothendieckTopology ↑Y) (IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map f)))

tactic: apply compatiblePreservingOfDownwardsClosed
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ((forget TopCat).map f)
this : Mono f
⊢ CompatiblePreserving (Opens.grothendieckTopology ↑Y) (IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map f)))

tactic: intro U V i
state_before: case hF
C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ((forget TopCat).map f)
this : Mono f
⊢ {c : Opens ↑X} →
    {d : Opens ↑Y} →
      (d ⟶ (IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map f))).obj c) →
        (c' : Opens ↑X) × ((IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map f))).obj c' ≅ d)

tactic: refine' ⟨(Opens.map f).obj V, eqToIso <| Opens.ext <| Set.image_preimage_eq_of_subset fun x h ↦ _⟩
state_before: case hF
C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ((forget TopCat).map f)
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ (IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map f))).obj U
⊢ (c' : Opens ↑X) × ((IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map f))).obj c' ≅ V)

tactic: obtain ⟨_, _, rfl⟩ := i.le h
state_before: case hF
C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ((forget TopCat).map f)
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ (IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map f))).obj U
x : ↑Y
h : x ∈ V.1
⊢ x ∈ Set.range fun x => (forget TopCat).map f x

tactic: exact ⟨_, rfl⟩
state_before: case hF.intro.intro
C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ((forget TopCat).map f)
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ (IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map f))).obj U
w✝ : (forget TopCat).obj X
left✝ : w✝ ∈ ↑U
h : (forget TopCat).map f w✝ ∈ V.1
⊢ (forget TopCat).map f w✝ ∈ Set.range fun x => (forget TopCat).map f x
Theorem: maximals_eq_minimals
File: Mathlib/Order/Minimal.lean

tactic: rw [minimals_of_symm, maximals_of_symm]
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a b : α
inst✝ : IsSymm α r
⊢ maximals r s = minimals r s
Theorem: Rat.mul_zero
File: Std/Data/Rat/Lemmas.lean

tactic: simp [mul_def]
state_before: a : Rat
⊢ a * 0 = 0
Theorem: NNReal.le_add_nndist
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: suffices (a : ℝ) ≤ (b : ℝ) + dist a b by
  rwa [← NNReal.coe_le_coe, NNReal.coe_add, coe_nndist]
state_before: α : Type u
β : Type v
X : Type ?u.239808
ι : Type ?u.239811
inst✝ : PseudoMetricSpace α
a b : ℝ≥0
⊢ a ≤ b + nndist a b

tactic: rw [← sub_le_iff_le_add']
state_before: α : Type u
β : Type v
X : Type ?u.239808
ι : Type ?u.239811
inst✝ : PseudoMetricSpace α
a b : ℝ≥0
⊢ ↑a ≤ ↑b + dist a b

tactic: exact le_of_abs_le (dist_eq a b).ge
state_before: α : Type u
β : Type v
X : Type ?u.239808
ι : Type ?u.239811
inst✝ : PseudoMetricSpace α
a b : ℝ≥0
⊢ ↑a - ↑b ≤ dist a b

tactic: rwa [← NNReal.coe_le_coe, NNReal.coe_add, coe_nndist]
state_before: α : Type u
β : Type v
X : Type ?u.239808
ι : Type ?u.239811
inst✝ : PseudoMetricSpace α
a b : ℝ≥0
this : ↑a ≤ ↑b + dist a b
⊢ a ≤ b + nndist a b
Theorem: Set.prod_insert
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.20280
δ : Type ?u.20283
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s ×ˢ insert b t = (fun a => (a, b)) '' s ∪ s ×ˢ t

tactic: simp [image, or_imp]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.20280
δ : Type ?u.20283
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ insert b t ↔ (x, y) ∈ (fun a => (a, b)) '' s ∪ s ×ˢ t

tactic: refine ⟨fun h => ?_, fun h => ?_⟩
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.20280
δ : Type ?u.20283
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ x ∈ s ∧ (y = b ∨ y ∈ t) ↔ (∃ a, a ∈ s ∧ a = x ∧ b = y) ∨ x ∈ s ∧ y ∈ t

tactic: obtain ⟨hx, rfl|hy⟩ := h
state_before: case h.mk.refine_1
α : Type u_1
β : Type u_2
γ : Type ?u.20280
δ : Type ?u.20283
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
h : x ∈ s ∧ (y = b ∨ y ∈ t)
⊢ (∃ a, a ∈ s ∧ a = x ∧ b = y) ∨ x ∈ s ∧ y ∈ t

tactic: exact Or.inl ⟨x, hx, rfl, rfl⟩
state_before: case h.mk.refine_1.intro.inl
α : Type u_1
β : Type u_2
γ : Type ?u.20280
δ : Type ?u.20283
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a x : α
y : β
hx : x ∈ s
⊢ (∃ a, a ∈ s ∧ a = x ∧ y = y) ∨ x ∈ s ∧ y ∈ t

tactic: exact Or.inr ⟨hx, hy⟩
state_before: case h.mk.refine_1.intro.inr
α : Type u_1
β : Type u_2
γ : Type ?u.20280
δ : Type ?u.20283
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
hx : x ∈ s
hy : y ∈ t
⊢ (∃ a, a ∈ s ∧ a = x ∧ b = y) ∨ x ∈ s ∧ y ∈ t

tactic: obtain ⟨x, hx, rfl, rfl⟩|⟨hx, hy⟩ := h
state_before: case h.mk.refine_2
α : Type u_1
β : Type u_2
γ : Type ?u.20280
δ : Type ?u.20283
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
h : (∃ a, a ∈ s ∧ a = x ∧ b = y) ∨ x ∈ s ∧ y ∈ t
⊢ x ∈ s ∧ (y = b ∨ y ∈ t)

tactic: exact ⟨hx, Or.inl rfl⟩
state_before: case h.mk.refine_2.inl.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.20280
δ : Type ?u.20283
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
hx : x ∈ s
⊢ x ∈ s ∧ (b = b ∨ b ∈ t)

tactic: exact ⟨hx, Or.inr hy⟩
state_before: case h.mk.refine_2.inr.intro
α : Type u_1
β : Type u_2
γ : Type ?u.20280
δ : Type ?u.20283
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
hx : x ∈ s
hy : y ∈ t
⊢ x ∈ s ∧ (y = b ∨ y ∈ t)
Theorem: Ordinal.lift_lt
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simp only [lt_iff_le_not_le, lift_le]
state_before: α : Type ?u.111454
β : Type ?u.111457
γ : Type ?u.111460
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
⊢ lift a < lift b ↔ a < b
Theorem: Polynomial.mod_eq_self_iff
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: have : ¬degree (q * C (leadingCoeff q)⁻¹) ≤ degree p :=
  not_le_of_gt <| by rwa [degree_mul_leadingCoeff_inv q hq0]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hq0 : q ≠ 0
h : degree p < degree q
⊢ p % q = p

tactic: rw [mod_def, modByMonic, dif_pos (monic_mul_leadingCoeff_inv hq0)]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hq0 : q ≠ 0
h : degree p < degree q
this : ¬degree (q * ↑C (leadingCoeff q)⁻¹) ≤ degree p
⊢ p % q = p

tactic: unfold divModByMonicAux
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hq0 : q ≠ 0
h : degree p < degree q
this : ¬degree (q * ↑C (leadingCoeff q)⁻¹) ≤ degree p
⊢ (divModByMonicAux p (_ : Monic (q * ↑C (leadingCoeff q)⁻¹))).snd = p

tactic: dsimp
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hq0 : q ≠ 0
h : degree p < degree q
this : ¬degree (q * ↑C (leadingCoeff q)⁻¹) ≤ degree p
⊢ (if h : degree (q * ↑C (leadingCoeff q)⁻¹) ≤ degree p ∧ p ≠ 0 then
        let z := ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree (q * ↑C (leadingCoeff q)⁻¹));
        let_fun _wf :=
          (_ :
            degree
                (p -
                  ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree (q * ↑C (leadingCoeff q)⁻¹)) *
                    (q * ↑C (leadingCoeff q)⁻¹)) <
              degree p);
        let dm := divModByMonicAux (p - z * (q * ↑C (leadingCoeff q)⁻¹)) (_ : Monic (q * ↑C (leadingCoeff q)⁻¹));
        (z + dm.fst, dm.snd)
      else (0, p)).snd =
    p

tactic: simp only [this, false_and_iff, if_false]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hq0 : q ≠ 0
h : degree p < degree q
this : ¬degree (q * ↑C (leadingCoeff q)⁻¹) ≤ degree p
⊢ (if degree (q * ↑C (leadingCoeff q)⁻¹) ≤ degree p ∧ ¬p = 0 then
        (↑C (leadingCoeff p) * X ^ (natDegree p - natDegree (q * ↑C (leadingCoeff q)⁻¹)) +
            (divModByMonicAux
                (p -
                  ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree (q * ↑C (leadingCoeff q)⁻¹)) *
                    (q * ↑C (leadingCoeff q)⁻¹))
                (_ : Monic (q * ↑C (leadingCoeff q)⁻¹))).fst,
          (divModByMonicAux
              (p -
                ↑C (leadingCoeff p) * X ^ (natDegree p - natDegree (q * ↑C (leadingCoeff q)⁻¹)) *
                  (q * ↑C (leadingCoeff q)⁻¹))
              (_ : Monic (q * ↑C (leadingCoeff q)⁻¹))).snd)
      else (0, p)).snd =
    p

tactic: rwa [degree_mul_leadingCoeff_inv q hq0]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hq0 : q ≠ 0
h : degree p < degree q
⊢ degree (q * ↑C (leadingCoeff q)⁻¹) > degree p
Theorem: mul_inv_le_one_iff
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 : α
⊢ b ≤ 1 * a ↔ b ≤ a
Theorem: Set.pi_nonempty_iff
File: Mathlib/Data/Set/Prod.lean

tactic: simp [Classical.skolem, Set.Nonempty]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.116518
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ Set.Nonempty (pi s t) ↔ ∀ (i : ι), ∃ x, i ∈ s → x ∈ t i
Theorem: Finset.sup_inf_distrib_right
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [_root_.inf_comm, s.sup_inf_distrib_left]
state_before: F : Type ?u.139618
α : Type u_2
β : Type ?u.139624
γ : Type ?u.139627
ι : Type u_1
κ : Type ?u.139633
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
t : Finset κ
f✝ : ι → α
g : κ → α
a✝ : α
s : Finset ι
f : ι → α
a : α
⊢ sup s f ⊓ a = sup s fun i => f i ⊓ a

tactic: simp_rw [_root_.inf_comm]
state_before: F : Type ?u.139618
α : Type u_2
β : Type ?u.139624
γ : Type ?u.139627
ι : Type u_1
κ : Type ?u.139633
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
t : Finset κ
f✝ : ι → α
g : κ → α
a✝ : α
s : Finset ι
f : ι → α
a : α
⊢ (sup s fun i => a ⊓ f i) = sup s fun i => f i ⊓ a
Theorem: Multiset.add_inter_distrib
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [add_comm, inter_add_distrib, add_comm s, add_comm s]
state_before: α : Type u_1
β : Type ?u.189863
γ : Type ?u.189866
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a b : α
s t u : Multiset α
⊢ s + t ∩ u = (s + t) ∩ (s + u)
Theorem: ContDiffBump.tsupport_normed_eq
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: rw [tsupport, f.support_normed_eq, closure_ball _ f.rOut_pos.ne']
state_before: E : Type u_1
X : Type ?u.2093391
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace ℝ X
inst✝⁵ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
inst✝⁴ : MeasurableSpace E
μ : MeasureTheory.Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : Measure.IsOpenPosMeasure μ
⊢ tsupport (ContDiffBump.normed f μ) = closedBall c f.rOut
Theorem: WithTop.add_lt_add_left
File: Mathlib/Algebra/Order/Monoid/WithTop.lean

tactic: lift a to α using ha
state_before: α : Type u
β : Type v
inst✝² : Add α
a b c d : WithTop α
x y : α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1
ha : a ≠ ⊤
h : b < c
⊢ a + b < a + c

tactic: rcases lt_iff_exists_coe.1 h with ⟨b, rfl, h'⟩
state_before: case intro
α : Type u
β : Type v
inst✝² : Add α
b c d : WithTop α
x y : α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1
h : b < c
a : α
⊢ ↑a + b < ↑a + c

tactic: cases c
state_before: case intro.intro.intro
α : Type u
β : Type v
inst✝² : Add α
c d : WithTop α
x y : α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1
a b : α
h' h : ↑b < c
⊢ ↑a + ↑b < ↑a + c

tactic: exact coe_lt_top _
state_before: case intro.intro.intro.none
α : Type u
β : Type v
inst✝² : Add α
d : WithTop α
x y : α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1
a b : α
h' h : ↑b < none
⊢ ↑a + ↑b < ↑a + none

tactic: exact coe_lt_coe.2 (add_lt_add_left (coe_lt_coe.1 h) _)
state_before: case intro.intro.intro.some
α : Type u
β : Type v
inst✝² : Add α
d : WithTop α
x y : α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1
a b val✝ : α
h' h : ↑b < Option.some val✝
⊢ ↑a + ↑b < ↑a + Option.some val✝
Theorem: CategoryTheory.Abelian.isIso_of_isIso_of_isIso_of_isIso_of_isIso
File: Mathlib/CategoryTheory/Abelian/DiagramLemmas/Four.lean

tactic: apply mono_of_epi_of_mono_of_mono comm₁ comm₂ comm₃ hfg hgh hf'g' <;> infer_instance
state_before: V : Type u
inst✝⁵ : Category V
inst✝⁴ : Abelian V
A B C D A' B' C' D' : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
f' : A' ⟶ B'
g' : B' ⟶ C'
h' : C' ⟶ D'
α : A ⟶ A'
β : B ⟶ B'
γ : C ⟶ C'
δ : D ⟶ D'
comm₁ : α ≫ f' = f ≫ β
comm₂ : β ≫ g' = g ≫ γ
comm₃ : γ ≫ h' = h ≫ δ
E E' : V
i : D ⟶ E
i' : D' ⟶ E'
ε : E ⟶ E'
comm₄ : δ ≫ i' = i ≫ ε
hfg : Exact f g
hgh : Exact g h
hhi : Exact h i
hf'g' : Exact f' g'
hg'h' : Exact g' h'
hh'i' : Exact h' i'
inst✝³ : IsIso α
inst✝² : IsIso β
inst✝¹ : IsIso δ
inst✝ : IsIso ε
⊢ Mono γ

tactic: apply epi_of_epi_of_epi_of_mono comm₂ comm₃ comm₄ hhi hg'h' hh'i' <;> infer_instance
state_before: V : Type u
inst✝⁵ : Category V
inst✝⁴ : Abelian V
A B C D A' B' C' D' : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
f' : A' ⟶ B'
g' : B' ⟶ C'
h' : C' ⟶ D'
α : A ⟶ A'
β : B ⟶ B'
γ : C ⟶ C'
δ : D ⟶ D'
comm₁ : α ≫ f' = f ≫ β
comm₂ : β ≫ g' = g ≫ γ
comm₃ : γ ≫ h' = h ≫ δ
E E' : V
i : D ⟶ E
i' : D' ⟶ E'
ε : E ⟶ E'
comm₄ : δ ≫ i' = i ≫ ε
hfg : Exact f g
hgh : Exact g h
hhi : Exact h i
hf'g' : Exact f' g'
hg'h' : Exact g' h'
hh'i' : Exact h' i'
inst✝³ : IsIso α
inst✝² : IsIso β
inst✝¹ : IsIso δ
inst✝ : IsIso ε
this : Mono γ
⊢ Epi γ
Theorem: IsHomeomorphicTrivialFiberBundle.surjective_proj
File: Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean

tactic: obtain ⟨e, rfl⟩ := h.proj_eq
state_before: B : Type u_2
F : Type u_1
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalSpace Z
proj : Z → B
inst✝ : Nonempty F
h : IsHomeomorphicTrivialFiberBundle F proj
⊢ Function.Surjective proj

tactic: exact Prod.fst_surjective.comp e.surjective
state_before: case intro
B : Type u_2
F : Type u_1
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalSpace Z
inst✝ : Nonempty F
e : Z ≃ₜ B × F
h : IsHomeomorphicTrivialFiberBundle F (Prod.fst ∘ ↑e)
⊢ Function.Surjective (Prod.fst ∘ ↑e)
Theorem: Fin.castPred_mk
File: Mathlib/Data/Fin/Basic.lean

tactic: have : ¬castSucc (last n) < ⟨i, lt_succ_of_lt h⟩ := by
  simpa [lt_iff_val_lt_val] using le_of_lt_succ h
state_before: n✝ m n i : ℕ
h : i < n + 1
⊢ castPred { val := i, isLt := (_ : i < Nat.succ (n + 1)) } = { val := i, isLt := h }

tactic: simp [castPred, predAbove, this]
state_before: n✝ m n i : ℕ
h : i < n + 1
this : ¬↑castSucc (last n) < { val := i, isLt := (_ : i < Nat.succ (n + 1)) }
⊢ castPred { val := i, isLt := (_ : i < Nat.succ (n + 1)) } = { val := i, isLt := h }

tactic: simpa [lt_iff_val_lt_val] using le_of_lt_succ h
state_before: n✝ m n i : ℕ
h : i < n + 1
⊢ ¬↑castSucc (last n) < { val := i, isLt := (_ : i < Nat.succ (n + 1)) }
Theorem: UniformFun.tendsto_iff_tendstoUniformly
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: rw [(UniformFun.hasBasis_nhds α β f).tendsto_right_iff, TendstoUniformly]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.45029
ι : Type u_3
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
F : ι → α →ᵤ β
f : α →ᵤ β
⊢ Tendsto F p (𝓝 f) ↔ TendstoUniformly F f p

tactic: exact Iff.rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.45029
ι : Type u_3
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
F : ι → α →ᵤ β
f : α →ᵤ β
⊢ (∀ (i : Set (β × β)), i ∈ 𝓤 β → ∀ᶠ (x : ι) in p, F x ∈ {g | (f, g) ∈ UniformFun.gen α β i}) ↔
    ∀ (u : Set (β × β)), u ∈ 𝓤 β → ∀ᶠ (n : ι) in p, ∀ (x : α), (f x, F n x) ∈ u
Theorem: Filter.tendsto_prod_self_iff
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [tendsto_def, mem_prod_same_iff, prod_sub_preimage_iff, exists_prop, iff_self_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.47951
ι : Sort ?u.47954
f✝ : Filter α
f : α × α → β
x : Filter α
y : Filter β
⊢ Tendsto f (x ×ˢ x) y ↔ ∀ (W : Set β), W ∈ y → ∃ U, U ∈ x ∧ ∀ (x x' : α), x ∈ U → x' ∈ U → f (x, x') ∈ W
Theorem: HasDerivWithinAt.smul_const
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: have := hc.smul (hasDerivWithinAt_const x s f)
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : 𝕜 → 𝕜'
c' : 𝕜'
hc : HasDerivWithinAt c c' s x
f : F
⊢ HasDerivWithinAt (fun y => c y • f) (c' • f) s x

tactic: rwa [smul_zero, zero_add] at this
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : 𝕜 → 𝕜'
c' : 𝕜'
hc : HasDerivWithinAt c c' s x
f : F
this : HasDerivWithinAt (fun y => c y • f) (c x • 0 + c' • f) s x
⊢ HasDerivWithinAt (fun y => c y • f) (c' • f) s x
Theorem: CircleDeg1Lift.transnumAuxSeq_dist_lt
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: have : 0 < (2 ^ (n + 1) : ℝ) := pow_pos zero_lt_two _
state_before: f g : CircleDeg1Lift
n : ℕ
⊢ dist (transnumAuxSeq f n) (transnumAuxSeq f (n + 1)) < 1 / 2 / 2 ^ n

tactic: rw [div_div, ← pow_succ, ← abs_of_pos this]
state_before: f g : CircleDeg1Lift
n : ℕ
this : 0 < 2 ^ (n + 1)
⊢ dist (transnumAuxSeq f n) (transnumAuxSeq f (n + 1)) < 1 / 2 / 2 ^ n

tactic: replace := abs_pos.2 (ne_of_gt this)
state_before: f g : CircleDeg1Lift
n : ℕ
this : 0 < 2 ^ (n + 1)
⊢ dist (transnumAuxSeq f n) (transnumAuxSeq f (n + 1)) < 1 / abs (2 ^ (n + 1))

tactic: convert (div_lt_div_right this).2 ((f ^ 2 ^ n).dist_map_map_zero_lt (f ^ 2 ^ n)) using 1
state_before: f g : CircleDeg1Lift
n : ℕ
this : 0 < abs (2 ^ (n + 1))
⊢ dist (transnumAuxSeq f n) (transnumAuxSeq f (n + 1)) < 1 / abs (2 ^ (n + 1))

tactic: simp_rw [transnumAuxSeq, Real.dist_eq]
state_before: case h.e'_3
f g : CircleDeg1Lift
n : ℕ
this : 0 < abs (2 ^ (n + 1))
⊢ dist (transnumAuxSeq f n) (transnumAuxSeq f (n + 1)) =
    dist (↑(f ^ 2 ^ n) 0 + ↑(f ^ 2 ^ n) 0) (↑(f ^ 2 ^ n) (↑(f ^ 2 ^ n) 0)) / abs (2 ^ (n + 1))

tactic: rw [← abs_div, sub_div, pow_succ', pow_succ, ← two_mul, mul_div_mul_left _ _ (two_ne_zero' ℝ),
  pow_mul, sq, mul_apply]
state_before: case h.e'_3
f g : CircleDeg1Lift
n : ℕ
this : 0 < abs (2 ^ (n + 1))
⊢ abs (↑(f ^ 2 ^ n) 0 / 2 ^ n - ↑(f ^ 2 ^ (n + 1)) 0 / 2 ^ (n + 1)) =
    abs (↑(f ^ 2 ^ n) 0 + ↑(f ^ 2 ^ n) 0 - ↑(f ^ 2 ^ n) (↑(f ^ 2 ^ n) 0)) / abs (2 ^ (n + 1))
Theorem: CategoryTheory.Limits.ImageMap.map_uniq_aux
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: have : map ≫ image.ι g.hom = map' ≫ image.ι g.hom := by rw [map_ι,map_ι']
state_before: C : Type u
inst✝⁴ : Category C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ map = map'

tactic: apply (cancel_mono (image.ι g.hom)).1 this
state_before: C : Type u
inst✝⁴ : Category C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
this : map ≫ image.ι g.hom = map' ≫ image.ι g.hom
⊢ map = map'

tactic: rw [map_ι,map_ι']
state_before: C : Type u
inst✝⁴ : Category C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ map ≫ image.ι g.hom = map' ≫ image.ι g.hom
Theorem: Int.coe_nat_dvd
File: Mathlib/Data/Int/Dvd/Basic.lean

tactic: simp [m0] at ae
state_before: m n : ℕ
x✝ : ↑m ∣ ↑n
a : ℤ
ae : ↑n = ↑m * a
m0 : m = 0
⊢ m ∣ n

tactic: simp [ae, m0]
state_before: m n : ℕ
x✝ : ↑m ∣ ↑n
a : ℤ
m0 : m = 0
ae : n = 0
⊢ m ∣ n

tactic: cases'
  eq_ofNat_of_zero_le
    (@nonneg_of_mul_nonneg_right ℤ _ m a (by simp [ae.symm]) (by simpa using m0l)) with
  k e
state_before: m n : ℕ
x✝ : ↑m ∣ ↑n
a : ℤ
ae : ↑n = ↑m * a
m0l : m > 0
⊢ m ∣ n

tactic: subst a
state_before: case intro
m n : ℕ
x✝ : ↑m ∣ ↑n
a : ℤ
ae : ↑n = ↑m * a
m0l : m > 0
k : ℕ
e : a = ↑k
⊢ m ∣ n

tactic: exact ⟨k, Int.ofNat.inj ae⟩
state_before: case intro
m n : ℕ
x✝ : ↑m ∣ ↑n
m0l : m > 0
k : ℕ
ae : ↑n = ↑m * ↑k
⊢ m ∣ n

tactic: simp [ae.symm]
state_before: m n : ℕ
x✝ : ↑m ∣ ↑n
a : ℤ
ae : ↑n = ↑m * a
m0l : m > 0
⊢ 0 ≤ ↑m * a

tactic: simpa using m0l
state_before: m n : ℕ
x✝ : ↑m ∣ ↑n
a : ℤ
ae : ↑n = ↑m * a
m0l : m > 0
⊢ 0 < ↑m

tactic: rw [e, Int.ofNat_mul]
state_before: m n : ℕ
x✝ : m ∣ n
k : ℕ
e : n = m * k
⊢ ↑m * ↑k = ↑n
Theorem: hyperoperation_ge_three_eq_one
File: Mathlib/Data/Nat/Hyperoperation.lean

tactic: rw [hyperoperation]
state_before: n m : ℕ
⊢ hyperoperation (n + 3) m 0 = 1