tasksource/leandojo huggingface dataset:
Theorem: ack_two
File: Mathlib/Computability/Ackermann.lean

tactic: induction' n with n IH
state_before: n : ℕ
⊢ ack 2 n = 2 * n + 3

tactic: rfl
state_before: case zero

⊢ ack 2 zero = 2 * zero + 3

tactic: simpa [mul_succ]
state_before: case succ
n : ℕ
IH : ack 2 n = 2 * n + 3
⊢ ack 2 (succ n) = 2 * succ n + 3
Theorem: LieIdeal.incl_idealRange
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [LieHom.idealRange_eq_lieSpan_range, ← LieSubalgebra.coe_to_submodule, ←
  LieSubmodule.coe_toSubmodule_eq_iff, incl_range, coe_to_lieSubalgebra_to_submodule,
  LieSubmodule.coe_lieSpan_submodule_eq_iff]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ LieHom.idealRange (incl I) = I

tactic: use I
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ ∃ N, ↑N = ↑I
Theorem: le_map_div_add_map_div
File: Mathlib/Algebra/Order/Hom/Basic.lean

tactic: simpa only [div_mul_div_cancel'] using map_mul_le_add f (a / b) (b / c)
state_before: ι : Type ?u.16670
F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.16682
δ : Type ?u.16685
inst✝³ : Group α
inst✝² : AddCommSemigroup β
inst✝¹ : LE β
inst✝ : MulLEAddHomClass F α β
f : F
a b c : α
⊢ ↑f (a / c) ≤ ↑f (a / b) + ↑f (b / c)
Theorem: SimpleGraph.Walk.exists_boundary_dart
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction' p with _ x y w a p' ih
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
S : Set V
uS : u ∈ S
vS : ¬v ∈ S
⊢ ∃ d, d ∈ darts p ∧ d.fst ∈ S ∧ ¬d.snd ∈ S

tactic: cases vS uS
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
S : Set V
uS✝ : u ∈ S
vS✝ : ¬v ∈ S
u✝ : V
uS : u✝ ∈ S
vS : ¬u✝ ∈ S
⊢ ∃ d, d ∈ darts nil ∧ d.fst ∈ S ∧ ¬d.snd ∈ S

tactic: by_cases h : y ∈ S
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
S : Set V
uS✝ : u ∈ S
vS✝ : ¬v ∈ S
x y w : V
a : Adj G x y
p' : Walk G y w
ih : y ∈ S → ¬w ∈ S → ∃ d, d ∈ darts p' ∧ d.fst ∈ S ∧ ¬d.snd ∈ S
uS : x ∈ S
vS : ¬w ∈ S
⊢ ∃ d, d ∈ darts (cons a p') ∧ d.fst ∈ S ∧ ¬d.snd ∈ S

tactic: obtain ⟨d, hd, hcd⟩ := ih h vS
state_before: case pos
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
S : Set V
uS✝ : u ∈ S
vS✝ : ¬v ∈ S
x y w : V
a : Adj G x y
p' : Walk G y w
ih : y ∈ S → ¬w ∈ S → ∃ d, d ∈ darts p' ∧ d.fst ∈ S ∧ ¬d.snd ∈ S
uS : x ∈ S
vS : ¬w ∈ S
h : y ∈ S
⊢ ∃ d, d ∈ darts (cons a p') ∧ d.fst ∈ S ∧ ¬d.snd ∈ S

tactic: exact ⟨d, List.Mem.tail _ hd, hcd⟩
state_before: case pos.intro.intro
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
S : Set V
uS✝ : u ∈ S
vS✝ : ¬v ∈ S
x y w : V
a : Adj G x y
p' : Walk G y w
ih : y ∈ S → ¬w ∈ S → ∃ d, d ∈ darts p' ∧ d.fst ∈ S ∧ ¬d.snd ∈ S
uS : x ∈ S
vS : ¬w ∈ S
h : y ∈ S
d : Dart G
hd : d ∈ darts p'
hcd : d.fst ∈ S ∧ ¬d.snd ∈ S
⊢ ∃ d, d ∈ darts (cons a p') ∧ d.fst ∈ S ∧ ¬d.snd ∈ S

tactic: exact ⟨⟨(x, y), a⟩, List.Mem.head _, uS, h⟩
state_before: case neg
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
S : Set V
uS✝ : u ∈ S
vS✝ : ¬v ∈ S
x y w : V
a : Adj G x y
p' : Walk G y w
ih : y ∈ S → ¬w ∈ S → ∃ d, d ∈ darts p' ∧ d.fst ∈ S ∧ ¬d.snd ∈ S
uS : x ∈ S
vS : ¬w ∈ S
h : ¬y ∈ S
⊢ ∃ d, d ∈ darts (cons a p') ∧ d.fst ∈ S ∧ ¬d.snd ∈ S
Theorem: CategoryTheory.IsEquivalence.ofIso_trans
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: dsimp [ofIso]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F G H : C ⥤ D
e : F ≅ G
e' : G ≅ H
hF : IsEquivalence F
⊢ ofIso e' (ofIso e hF) = ofIso (e ≪≫ e') hF

tactic: congr 1 <;> ext X <;> dsimp [NatIso.hcomp]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F G H : C ⥤ D
e : F ≅ G
e' : G ≅ H
hF : IsEquivalence F
⊢ mk' (inverse F) ((unitIso ≪≫ hcomp e (Iso.refl (inverse F))) ≪≫ hcomp e' (Iso.refl (inverse F)))
      (hcomp (Iso.refl (inverse F)) e'.symm ≪≫ hcomp (Iso.refl (inverse F)) e.symm ≪≫ counitIso) =
    mk' (inverse F) (unitIso ≪≫ hcomp (e ≪≫ e') (Iso.refl (inverse F)))
      (hcomp (Iso.refl (inverse F)) (e'.symm ≪≫ e.symm) ≪≫ counitIso)

tactic: simp only [id_comp, assoc, Functor.map_comp]
state_before: case e_unitIso.w.w.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F G H : C ⥤ D
e : F ≅ G
e' : G ≅ H
hF : IsEquivalence F
X : C
⊢ (unitIso.hom.app X ≫ 𝟙 ((inverse F).obj (F.obj X)) ≫ (inverse F).map (e.hom.app X)) ≫
      𝟙 ((inverse F).obj (G.obj X)) ≫ (inverse F).map (e'.hom.app X) =
    unitIso.hom.app X ≫ 𝟙 ((inverse F).obj (F.obj X)) ≫ (inverse F).map (e.hom.app X ≫ e'.hom.app X)

tactic: simp only [Functor.map_id, comp_id, id_comp, assoc]
state_before: case e_counitIso.w.w.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F G H : C ⥤ D
e : F ≅ G
e' : G ≅ H
hF : IsEquivalence F
X : D
⊢ (e'.inv.app ((inverse F).obj X) ≫ G.map (𝟙 ((inverse F).obj X))) ≫
      (e.inv.app ((inverse F).obj X) ≫ F.map (𝟙 ((inverse F).obj X))) ≫ counitIso.hom.app X =
    ((e'.inv.app ((inverse F).obj X) ≫ e.inv.app ((inverse F).obj X)) ≫ F.map (𝟙 ((inverse F).obj X))) ≫
      counitIso.hom.app X
Theorem: Mathlib.Meta.NormNum.ble_eq_false
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rw [← Nat.not_le, ← Bool.not_eq_true, Nat.ble_eq]
state_before: x y : ℕ
⊢ Nat.ble x y = false ↔ y < x
Theorem: Bitraversable.comp_tfst
File: Mathlib/Control/Bitraversable/Lemmas.lean

tactic: rw [← comp_bitraverse]
state_before: t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
β✝ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : IsLawfulBitraversable t
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α₀ α₁ α₂ β : Type u
f : α₀ → F α₁
f' : α₁ → G α₂
x : t α₀ β
⊢ Comp.mk (tfst f' <$> tfst f x) = tfst (Comp.mk ∘ map f' ∘ f) x

tactic: simp only [Function.comp, tfst, map_pure, Pure.pure]
state_before: t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
β✝ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : IsLawfulBitraversable t
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α₀ α₁ α₂ β : Type u
f : α₀ → F α₁
f' : α₁ → G α₂
x : t α₀ β
⊢ bitraverse (Comp.mk ∘ map f' ∘ f) (Comp.mk ∘ map pure ∘ pure) x = tfst (Comp.mk ∘ map f' ∘ f) x
Theorem: interior_sphere
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: rw [← frontier_closedBall x hr, interior_frontier isClosed_ball]
state_before: α : Type ?u.89830
β : Type ?u.89833
γ : Type ?u.89836
ι : Type ?u.89839
inst✝⁶ : NormedField α
inst✝⁵ : SeminormedAddCommGroup β
E : Type u_1
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace α E
F : Type ?u.89870
inst✝² : SeminormedAddCommGroup F
inst✝¹ : NormedSpace α F
inst✝ : NormedSpace ℝ E
x : E
r : ℝ
hr : r ≠ 0
⊢ interior (sphere x r) = ∅
Theorem: Nat.factors_add_two
File: Mathlib/Data/Nat/Factors.lean

tactic: rw [factors]
state_before: n : ℕ
⊢ factors (n + 2) = minFac (n + 2) :: factors ((n + 2) / minFac (n + 2))
Theorem: LieSubmodule.comap_normalizer
File: Mathlib/Algebra/Lie/Normalizer.lean

tactic: ext
state_before: R : Type u_1
L : Type u_2
M : Type u_4
M' : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
f : M' →ₗ⁅R,L⁆ M
⊢ comap f (normalizer N) = normalizer (comap f N)

tactic: simp
state_before: case h
R : Type u_1
L : Type u_2
M : Type u_4
M' : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
f : M' →ₗ⁅R,L⁆ M
m✝ : M'
⊢ m✝ ∈ comap f (normalizer N) ↔ m✝ ∈ normalizer (comap f N)
Theorem: List.rotate_eq_rotate'
File: Mathlib/Data/List/Rotate.lean

tactic: simp_all [length_eq_zero]
state_before: α : Type u
l : List α
n : ℕ
h : length l = 0
⊢ rotate l n = rotate' l n

tactic: rw [← rotate'_mod,
    rotate'_eq_drop_append_take (le_of_lt (Nat.mod_lt _ (Nat.pos_of_ne_zero h)))]
state_before: α : Type u
l : List α
n : ℕ
h : ¬length l = 0
⊢ rotate l n = rotate' l n

tactic: simp [rotate]
state_before: α : Type u
l : List α
n : ℕ
h : ¬length l = 0
⊢ rotate l n = drop (n % length l) l ++ take (n % length l) l
Theorem: CategoryTheory.strongEpi_comp
File: Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean

tactic: intros
state_before: C : Type u
inst✝² : Category C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝¹ : StrongEpi f
inst✝ : StrongEpi g
⊢ ∀ ⦃X Y : C⦄ (z : X ⟶ Y) [inst : Mono z], HasLiftingProperty (f ≫ g) z

tactic: infer_instance
state_before: C : Type u
inst✝³ : Category C
P Q R : C
f : P ⟶ Q
g : Q ⟶ R
inst✝² : StrongEpi f
inst✝¹ : StrongEpi g
X✝ Y✝ : C
z✝ : X✝ ⟶ Y✝
inst✝ : Mono z✝
⊢ HasLiftingProperty (f ≫ g) z✝
Theorem: himp_bihimp
File: Mathlib/Order/SymmDiff.lean

tactic: rw [bihimp, himp_inf_distrib, himp_himp, himp_himp]
state_before: ι : Type ?u.45050
α : Type u_1
β : Type ?u.45056
π : ι → Type ?u.45061
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ a ⇨ b ⇔ c = (a ⊓ c ⇨ b) ⊓ (a ⊓ b ⇨ c)
Theorem: Rat.cast_inj
File: Mathlib/Data/Rat/Cast.lean

tactic: refine' ⟨fun h => _, congr_arg _⟩
state_before: F : Type ?u.40042
ι : Type ?u.40045
α : Type u_1
β : Type ?u.40051
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n₁ : ℤ
d₁ : ℕ
d₁0 : d₁ ≠ 0
c₁ : Nat.coprime (Int.natAbs n₁) d₁
n₂ : ℤ
d₂ : ℕ
d₂0 : d₂ ≠ 0
c₂ : Nat.coprime (Int.natAbs n₂) d₂
⊢ ↑(mk' n₁ d₁) = ↑(mk' n₂ d₂) ↔ mk' n₁ d₁ = mk' n₂ d₂

tactic: have d₁a : (d₁ : α) ≠ 0 := Nat.cast_ne_zero.2 d₁0
state_before: F : Type ?u.40042
ι : Type ?u.40045
α : Type u_1
β : Type ?u.40051
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n₁ : ℤ
d₁ : ℕ
d₁0 : d₁ ≠ 0
c₁ : Nat.coprime (Int.natAbs n₁) d₁
n₂ : ℤ
d₂ : ℕ
d₂0 : d₂ ≠ 0
c₂ : Nat.coprime (Int.natAbs n₂) d₂
h : ↑(mk' n₁ d₁) = ↑(mk' n₂ d₂)
⊢ mk' n₁ d₁ = mk' n₂ d₂

tactic: have d₂a : (d₂ : α) ≠ 0 := Nat.cast_ne_zero.2 d₂0
state_before: F : Type ?u.40042
ι : Type ?u.40045
α : Type u_1
β : Type ?u.40051
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n₁ : ℤ
d₁ : ℕ
d₁0 : d₁ ≠ 0
c₁ : Nat.coprime (Int.natAbs n₁) d₁
n₂ : ℤ
d₂ : ℕ
d₂0 : d₂ ≠ 0
c₂ : Nat.coprime (Int.natAbs n₂) d₂
h : ↑(mk' n₁ d₁) = ↑(mk' n₂ d₂)
d₁a : ↑d₁ ≠ 0
⊢ mk' n₁ d₁ = mk' n₂ d₂

tactic: rw [num_den', num_den'] at h⊢
state_before: F : Type ?u.40042
ι : Type ?u.40045
α : Type u_1
β : Type ?u.40051
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n₁ : ℤ
d₁ : ℕ
d₁0 : d₁ ≠ 0
c₁ : Nat.coprime (Int.natAbs n₁) d₁
n₂ : ℤ
d₂ : ℕ
d₂0 : d₂ ≠ 0
c₂ : Nat.coprime (Int.natAbs n₂) d₂
h : ↑(mk' n₁ d₁) = ↑(mk' n₂ d₂)
d₁a : ↑d₁ ≠ 0
d₂a : ↑d₂ ≠ 0
⊢ mk' n₁ d₁ = mk' n₂ d₂

tactic: rw [cast_mk_of_ne_zero, cast_mk_of_ne_zero] at h <;> simp [d₁0, d₂0] at h⊢
state_before: F : Type ?u.40042
ι : Type ?u.40045
α : Type u_1
β : Type ?u.40051
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n₁ : ℤ
d₁ : ℕ
d₁0 : d₁ ≠ 0
c₁ : Nat.coprime (Int.natAbs n₁) d₁
n₂ : ℤ
d₂ : ℕ
d₂0 : d₂ ≠ 0
c₂ : Nat.coprime (Int.natAbs n₂) d₂
h : ↑(n₁ /. ↑d₁) = ↑(n₂ /. ↑d₂)
d₁a : ↑d₁ ≠ 0
d₂a : ↑d₂ ≠ 0
⊢ n₁ /. ↑d₁ = n₂ /. ↑d₂

tactic: rwa [eq_div_iff_mul_eq d₂a, division_def, mul_assoc, (d₁.cast_commute (d₂ : α)).inv_left₀.eq, ←
  mul_assoc, ← division_def, eq_comm, eq_div_iff_mul_eq d₁a, eq_comm, ← Int.cast_ofNat d₁, ←
  Int.cast_mul, ← Int.cast_ofNat d₂, ← Int.cast_mul, Int.cast_inj, ← mkRat_eq_iff d₁0 d₂0] at h
state_before: F : Type ?u.40042
ι : Type ?u.40045
α : Type u_1
β : Type ?u.40051
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n₁ : ℤ
d₁ : ℕ
d₁0 : d₁ ≠ 0
c₁ : Nat.coprime (Int.natAbs n₁) d₁
n₂ : ℤ
d₂ : ℕ
d₂0 : d₂ ≠ 0
c₂ : Nat.coprime (Int.natAbs n₂) d₂
d₁a : ↑d₁ ≠ 0
d₂a : ↑d₂ ≠ 0
h : ↑n₁ / ↑d₁ = ↑n₂ / ↑d₂
⊢ mkRat n₁ d₁ = mkRat n₂ d₂
Theorem: convexJoin_comm
File: Mathlib/Analysis/Convex/Join.lean

tactic: simp_rw [convexJoin, segment_symm]
state_before: ι : Sort ?u.12394
𝕜 : Type u_2
E : Type u_1
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s✝ t✝ s₁ s₂ t₁ t₂ u : Set E
x y : E
s t : Set E
⊢ (⋃ (i₂ : E) (_ : i₂ ∈ t) (i₁ : E) (_ : i₁ ∈ s), segment 𝕜 i₁ i₂) = convexJoin 𝕜 t s
Theorem: CategoryTheory.Limits.IsLimit.lift_comp_conePointsIsoOfNatIso_inv
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
r s : Cone G
t : Cone F
P : IsLimit t
Q : IsLimit s
w : F ≅ G
⊢ ∀ (j : J), (lift Q r ≫ (conePointsIsoOfNatIso P Q w).inv) ≫ t.π.app j = map r P w.inv ≫ t.π.app j
Theorem: div_eq_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [h, div_self']
state_before: α : Type ?u.61400
β : Type ?u.61403
G : Type u_1
inst✝ : Group G
a b c d : G
h : a = b
⊢ a / b = 1
Theorem: Besicovitch.multiplicity_le
File: Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean

tactic: apply csSup_le
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ multiplicity E ≤ 5 ^ finrank ℝ E

tactic: refine' ⟨0, ⟨∅, by simp⟩⟩
state_before: case h₁
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ Set.Nonempty
    {N |
      ∃ s, Finset.card s = N ∧ (∀ (c : E), c ∈ s → ‖c‖ ≤ 2) ∧ ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖}

tactic: simp
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ Finset.card ∅ = 0 ∧ (∀ (c : E), c ∈ ∅ → ‖c‖ ≤ 2) ∧ ∀ (c : E), c ∈ ∅ → ∀ (d : E), d ∈ ∅ → c ≠ d → 1 ≤ ‖c - d‖

tactic: rintro _ ⟨s, ⟨rfl, h⟩⟩
state_before: case h₂
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ ∀ (b : ℕ),
    b ∈
        {N |
          ∃ s,
            Finset.card s = N ∧
              (∀ (c : E), c ∈ s → ‖c‖ ≤ 2) ∧ ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖} →
      b ≤ 5 ^ finrank ℝ E

tactic: exact Besicovitch.card_le_of_separated s h.1 h.2
state_before: case h₂.intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
s : Finset E
h : (∀ (c : E), c ∈ s → ‖c‖ ≤ 2) ∧ ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖
⊢ Finset.card s ≤ 5 ^ finrank ℝ E
Theorem: Rat.cast_inv_int
File: Mathlib/Data/Rat/Cast.lean

tactic: cases' n with n n
state_before: F : Type ?u.33624
ι : Type ?u.33627
α : Type u_1
β : Type ?u.33633
inst✝ : DivisionRing α
n : ℤ
⊢ ↑(↑n)⁻¹ = (↑n)⁻¹

tactic: simp [ofInt_eq_cast, cast_inv_nat]
state_before: case ofNat
F : Type ?u.33624
ι : Type ?u.33627
α : Type u_1
β : Type ?u.33633
inst✝ : DivisionRing α
n : ℕ
⊢ ↑(↑(Int.ofNat n))⁻¹ = (↑(Int.ofNat n))⁻¹

tactic: simp only [ofInt_eq_cast, Int.cast_negSucc, ← Nat.cast_succ, cast_neg, inv_neg, cast_inv_nat]
state_before: case negSucc
F : Type ?u.33624
ι : Type ?u.33627
α : Type u_1
β : Type ?u.33633
inst✝ : DivisionRing α
n : ℕ
⊢ ↑(↑(Int.negSucc n))⁻¹ = (↑(Int.negSucc n))⁻¹
Theorem: integral_one_div_one_add_sq
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simp only [one_div, integral_inv_one_add_sq]
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, 1 / (1 + x ^ 2)) = arctan b - arctan a
Theorem: Metric.frontier_thickening_disjoint
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: refine' (pairwise_disjoint_on _).2 fun r₁ r₂ hr => _
state_before: ι : Sort ?u.92543
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x : α
A : Set α
⊢ Pairwise (Disjoint on fun r => frontier (thickening r A))

tactic: cases' le_total r₁ 0 with h₁ h₁
state_before: ι : Sort ?u.92543
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x : α
A : Set α
r₁ r₂ : ℝ
hr : r₁ < r₂
⊢ Disjoint (frontier (thickening r₁ A)) (frontier (thickening r₂ A))

tactic: refine' ((disjoint_singleton.2 fun h => hr.ne _).preimage _).mono (frontier_thickening_subset _)
  (frontier_thickening_subset _)
state_before: case inr
ι : Sort ?u.92543
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x : α
A : Set α
r₁ r₂ : ℝ
hr : r₁ < r₂
h₁ : 0 ≤ r₁
⊢ Disjoint (frontier (thickening r₁ A)) (frontier (thickening r₂ A))

tactic: apply_fun ENNReal.toReal at h
state_before: case inr
ι : Sort ?u.92543
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x : α
A : Set α
r₁ r₂ : ℝ
hr : r₁ < r₂
h₁ : 0 ≤ r₁
h : ENNReal.ofReal r₁ = ENNReal.ofReal r₂
⊢ r₁ = r₂

tactic: rwa [ENNReal.toReal_ofReal h₁, ENNReal.toReal_ofReal (h₁.trans hr.le)] at h
state_before: case inr
ι : Sort ?u.92543
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x : α
A : Set α
r₁ r₂ : ℝ
hr : r₁ < r₂
h₁ : 0 ≤ r₁
h : ENNReal.toReal (ENNReal.ofReal r₁) = ENNReal.toReal (ENNReal.ofReal r₂)
⊢ r₁ = r₂

tactic: simp [thickening_of_nonpos h₁]
state_before: case inl
ι : Sort ?u.92543
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x : α
A : Set α
r₁ r₂ : ℝ
hr : r₁ < r₂
h₁ : r₁ ≤ 0
⊢ Disjoint (frontier (thickening r₁ A)) (frontier (thickening r₂ A))
Theorem: aux
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: simp only [Algebra.id.smul_eq_mul, one_mul, ContinuousLinearMap.one_apply,
  ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.add_apply, Pi.smul_apply,
  ContinuousLinearMap.coe_smul']
state_before: f g : ℂ → ℂ
s : Set ℂ
f' g' x c : ℂ
⊢ ↑((g x * f x ^ (g x - 1)) • ContinuousLinearMap.smulRight 1 f' +
          (f x ^ g x * log (f x)) • ContinuousLinearMap.smulRight 1 g')
      1 =
    g x * f x ^ (g x - 1) * f' + f x ^ g x * log (f x) * g'
Theorem: Cube.boundary_one
File: Mathlib/Topology/Homotopy/HomotopyGroup.lean

tactic: ext x
state_before: X : Type u
inst✝ : TopologicalSpace X
n : ℕ
x : X
⊢ boundary 1 = {0, 1}

tactic: rw [mem_boundary, Fin.exists_fin_one, mem_insert_iff, mem_singleton_iff,
  Function.funext_iff, Function.funext_iff, Fin.forall_fin_one, Fin.forall_fin_one]
state_before: case h
X : Type u
inst✝ : TopologicalSpace X
n : ℕ
x✝ : X
x : I^ 1
⊢ x ∈ boundary 1 ↔ x ∈ {0, 1}

tactic: rfl
state_before: case h
X : Type u
inst✝ : TopologicalSpace X
n : ℕ
x✝ : X
x : I^ 1
⊢ x 0 = 0 ∨ x 0 = 1 ↔ x 0 = OfNat.ofNat 0 0 ∨ x 0 = OfNat.ofNat 1 0
Theorem: Int.ediv_eq_of_eq_mul_right
File: Std/Data/Int/DivMod.lean

tactic: rw [H2, Int.mul_ediv_cancel_left _ H1]
state_before: a b c : Int
H1 : b ≠ 0
H2 : a = b * c
⊢ a / b = c
Theorem: Matrix.invOf_eq
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: letI := invertibleOfDetInvertible A
state_before: l : Type ?u.30804
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Invertible (det A)
inst✝ : Invertible A
⊢ ⅟A = ⅟(det A) • adjugate A

tactic: convert(rfl : ⅟ A = _)
state_before: l : Type ?u.30804
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Invertible (det A)
inst✝ : Invertible A
this : Invertible A := invertibleOfDetInvertible A
⊢ ⅟A = ⅟(det A) • adjugate A
Theorem: YoungDiagram.rowLen_transpose
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: simp [rowLen, colLen]
state_before: μ : YoungDiagram
i : ℕ
⊢ rowLen (transpose μ) i = colLen μ i
Theorem: IsCyclic.exponent_eq_card
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: obtain ⟨g, hg⟩ := IsCyclic.exists_generator (α := α)
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : IsCyclic α
inst✝ : Fintype α
⊢ exponent α = Fintype.card α

tactic: apply Nat.dvd_antisymm
state_before: case intro
α : Type u
a : α
inst✝² : Group α
inst✝¹ : IsCyclic α
inst✝ : Fintype α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
⊢ exponent α = Fintype.card α

tactic: rw [← orderOf_eq_card_of_forall_mem_zpowers hg]
state_before: case intro.a
α : Type u
a : α
inst✝² : Group α
inst✝¹ : IsCyclic α
inst✝ : Fintype α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
⊢ Fintype.card α ∣ exponent α

tactic: exact order_dvd_exponent _
state_before: case intro.a
α : Type u
a : α
inst✝² : Group α
inst✝¹ : IsCyclic α
inst✝ : Fintype α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
⊢ orderOf g ∣ exponent α

tactic: rw [← lcm_order_eq_exponent, Finset.lcm_dvd_iff]
state_before: case intro.a
α : Type u
a : α
inst✝² : Group α
inst✝¹ : IsCyclic α
inst✝ : Fintype α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
⊢ exponent α ∣ Fintype.card α

tactic: exact fun b _ => orderOf_dvd_card_univ
state_before: case intro.a
α : Type u
a : α
inst✝² : Group α
inst✝¹ : IsCyclic α
inst✝ : Fintype α
g : α
hg : ∀ (x : α), x ∈ Subgroup.zpowers g
⊢ ∀ (b : α), b ∈ Finset.univ → orderOf b ∣ Fintype.card α
Theorem: List.rel_reverse
File: Mathlib/Data/List/Forall2.lean

tactic: simp only [reverse_cons]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.140328
δ : Type ?u.140331
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (reverse (a✝ :: l₁✝)) (reverse (b✝ :: l₂✝))

tactic: exact rel_append (rel_reverse h₂) (Forall₂.cons h₁ Forall₂.nil)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.140328
δ : Type ?u.140331
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (reverse l₁✝ ++ [a✝]) (reverse l₂✝ ++ [b✝])
Theorem: MeasureTheory.measure_union_congr_of_subset
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [union_eq_iUnion, union_eq_iUnion]
state_before: α : Type u_1
β : Type ?u.36188
γ : Type ?u.36191
δ : Type ?u.36194
ι : Type ?u.36197
R : Type ?u.36200
R' : Type ?u.36203
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t t₁ t₂ : Set α
hs : s₁ ⊆ s₂
hsμ : ↑↑μ s₂ ≤ ↑↑μ s₁
ht : t₁ ⊆ t₂
htμ : ↑↑μ t₂ ≤ ↑↑μ t₁
⊢ ↑↑μ (s₁ ∪ t₁) = ↑↑μ (s₂ ∪ t₂)

tactic: exact measure_iUnion_congr_of_subset (Bool.forall_bool.2 ⟨ht, hs⟩) (Bool.forall_bool.2 ⟨htμ, hsμ⟩)
state_before: α : Type u_1
β : Type ?u.36188
γ : Type ?u.36191
δ : Type ?u.36194
ι : Type ?u.36197
R : Type ?u.36200
R' : Type ?u.36203
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t t₁ t₂ : Set α
hs : s₁ ⊆ s₂
hsμ : ↑↑μ s₂ ≤ ↑↑μ s₁
ht : t₁ ⊆ t₂
htμ : ↑↑μ t₂ ≤ ↑↑μ t₁
⊢ ↑↑μ (⋃ (b : Bool), bif b then s₁ else t₁) = ↑↑μ (⋃ (b : Bool), bif b then s₂ else t₂)
Theorem: tendsto_uniformity_iff_dist_tendsto_zero
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [Metric.uniformity_eq_comap_nhds_zero, tendsto_comap_iff]
state_before: α : Type u
β : Type v
X : Type ?u.214516
ι✝ : Type ?u.214519
inst✝ : PseudoMetricSpace α
ι : Type u_1
f : ι → α × α
p : Filter ι
⊢ Tendsto f p (𝓤 α) ↔ Tendsto (fun x => dist (f x).fst (f x).snd) p (𝓝 0)

tactic: rfl
state_before: α : Type u
β : Type v
X : Type ?u.214516
ι✝ : Type ?u.214519
inst✝ : PseudoMetricSpace α
ι : Type u_1
f : ι → α × α
p : Filter ι
⊢ Tendsto ((fun p => dist p.fst p.snd) ∘ f) p (𝓝 0) ↔ Tendsto (fun x => dist (f x).fst (f x).snd) p (𝓝 0)