1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.hasFiniteCoproducts_of_has_binary_and_initial
File: Mathlib/CategoryTheory/Limits/Constructions/FiniteProductsOfBinaryProducts.lean

tactic: refine ⟨fun n => ⟨fun K => ?_⟩⟩
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
⊢ HasFiniteCoproducts C
state_after: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
K : Discrete (Fin n) ⥤ C
⊢ HasColimit K

tactic: letI := hasCoproduct_fin n fun n => K.obj ⟨n⟩
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
K : Discrete (Fin n) ⥤ C
⊢ HasColimit K
state_after: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
K : Discrete (Fin n) ⥤ C
this : HasCoproduct fun n_1 => K.obj { as := n_1 } := CategoryTheory.hasCoproduct_fin n fun n_1 => K.obj { as := n_1 }
⊢ HasColimit K

tactic: let that : K ≅ Discrete.functor fun n => K.obj ⟨n⟩ := Discrete.natIso fun ⟨i⟩ => Iso.refl _
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
K : Discrete (Fin n) ⥤ C
this : HasCoproduct fun n_1 => K.obj { as := n_1 } := CategoryTheory.hasCoproduct_fin n fun n_1 => K.obj { as := n_1 }
⊢ HasColimit K
state_after: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
K : Discrete (Fin n) ⥤ C
this : HasCoproduct fun n_1 => K.obj { as := n_1 } := CategoryTheory.hasCoproduct_fin n fun n_1 => K.obj { as := n_1 }
that : K ≅ Discrete.functor fun n_1 => K.obj { as := n_1 } :=
  Discrete.natIso fun x =>
    match x with
    | { as := i } => Iso.refl (K.obj { as := i })
⊢ HasColimit K

tactic: apply @hasColimitOfIso _ _ _ _ _ _ this that
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
K : Discrete (Fin n) ⥤ C
this : HasCoproduct fun n_1 => K.obj { as := n_1 } := CategoryTheory.hasCoproduct_fin n fun n_1 => K.obj { as := n_1 }
that : K ≅ Discrete.functor fun n_1 => K.obj { as := n_1 } :=
  Discrete.natIso fun x =>
    match x with
    | { as := i } => Iso.refl (K.obj { as := i })
⊢ HasColimit K
state_after: no goals
Theorem: RatFunc.single_zpow
File: Mathlib/RingTheory/LaurentSeries.lean

tactic: induction' n with n_pos n_neg
state_before: R : Type u_1
F : Type u
inst✝ : Field F
p q : F[X]
f g : RatFunc F
n : ℤ
⊢ (single n) 1 = (single 1) 1 ^ n
state_after: case ofNat
R : Type u_1
F : Type u
inst✝ : Field F
p q : F[X]
f g : RatFunc F
n_pos : ℕ
⊢ (single (Int.ofNat n_pos)) 1 = (single 1) 1 ^ Int.ofNat n_pos

case negSucc
R : Type u_1
F : Type u
inst✝ : Field F
p q : F[X]
f g : RatFunc F
n_neg : ℕ
⊢ (single (Int.negSucc n_neg)) 1 = (single 1) 1 ^ Int.negSucc n_neg

tactic: apply single_one_eq_pow
state_before: case ofNat
R : Type u_1
F : Type u
inst✝ : Field F
p q : F[X]
f g : RatFunc F
n_pos : ℕ
⊢ (single (Int.ofNat n_pos)) 1 = (single 1) 1 ^ Int.ofNat n_pos
state_after: no goals

tactic: rw [Int.negSucc_coe, Int.ofNat_add, Nat.cast_one, ← inv_one,
  single_inv (n_neg + 1 : ℤ) one_ne_zero, zpow_neg, ← Nat.cast_one, ← Int.ofNat_add,
  Nat.cast_one, inv_inj, zpow_natCast, single_one_eq_pow, inv_one]
state_before: case negSucc
R : Type u_1
F : Type u
inst✝ : Field F
p q : F[X]
f g : RatFunc F
n_neg : ℕ
⊢ (single (Int.negSucc n_neg)) 1 = (single 1) 1 ^ Int.negSucc n_neg
state_after: no goals
Theorem: SimpleGraph.isClique_empty
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t : Set α
a b : α
⊢ G.IsClique ∅
state_after: no goals
Theorem: Ordinal.opow_le_opow_left
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: by_cases a0 : a = 0
state_before: a b c : Ordinal.{u_1}
ab : a ≤ b
⊢ a ^ c ≤ b ^ c
state_after: case pos
a b c : Ordinal.{u_1}
ab : a ≤ b
a0 : a = 0
⊢ a ^ c ≤ b ^ c

case neg
a b c : Ordinal.{u_1}
ab : a ≤ b
a0 : ¬a = 0
⊢ a ^ c ≤ b ^ c

tactic: subst a
state_before: case pos
a b c : Ordinal.{u_1}
ab : a ≤ b
a0 : a = 0
⊢ a ^ c ≤ b ^ c
state_after: case pos
b c : Ordinal.{u_1}
ab : 0 ≤ b
⊢ 0 ^ c ≤ b ^ c

tactic: by_cases c0 : c = 0
state_before: case pos
b c : Ordinal.{u_1}
ab : 0 ≤ b
⊢ 0 ^ c ≤ b ^ c
state_after: case pos
b c : Ordinal.{u_1}
ab : 0 ≤ b
c0 : c = 0
⊢ 0 ^ c ≤ b ^ c

case neg
b c : Ordinal.{u_1}
ab : 0 ≤ b
c0 : ¬c = 0
⊢ 0 ^ c ≤ b ^ c

tactic: subst c
state_before: case pos
b c : Ordinal.{u_1}
ab : 0 ≤ b
c0 : c = 0
⊢ 0 ^ c ≤ b ^ c
state_after: case pos
b : Ordinal.{u_1}
ab : 0 ≤ b
⊢ 0 ^ 0 ≤ b ^ 0

tactic: simp only [opow_zero, le_refl]
state_before: case pos
b : Ordinal.{u_1}
ab : 0 ≤ b
⊢ 0 ^ 0 ≤ b ^ 0
state_after: no goals

tactic: simp only [zero_opow c0, Ordinal.zero_le]
state_before: case neg
b c : Ordinal.{u_1}
ab : 0 ≤ b
c0 : ¬c = 0
⊢ 0 ^ c ≤ b ^ c
state_after: no goals

tactic: induction c using limitRecOn with
| H₁ => simp only [opow_zero, le_refl]
| H₂ c IH =>
  simpa only [opow_succ] using mul_le_mul' IH ab
| H₃ c l IH =>
  exact
    (opow_le_of_limit a0 l).2 fun b' h =>
      (IH _ h).trans (opow_le_opow_right ((Ordinal.pos_iff_ne_zero.2 a0).trans_le ab) h.le)
state_before: case neg
a b c : Ordinal.{u_1}
ab : a ≤ b
a0 : ¬a = 0
⊢ a ^ c ≤ b ^ c
state_after: no goals

tactic: simp only [opow_zero, le_refl]
state_before: case neg.H₁
a b : Ordinal.{u_1}
ab : a ≤ b
a0 : ¬a = 0
⊢ a ^ 0 ≤ b ^ 0
state_after: no goals

tactic: simpa only [opow_succ] using mul_le_mul' IH ab
state_before: case neg.H₂
a b : Ordinal.{u_1}
ab : a ≤ b
a0 : ¬a = 0
c : Ordinal.{u_1}
IH : a ^ c ≤ b ^ c
⊢ a ^ succ c ≤ b ^ succ c
state_after: no goals

tactic: exact
  (opow_le_of_limit a0 l).2 fun b' h =>
    (IH _ h).trans (opow_le_opow_right ((Ordinal.pos_iff_ne_zero.2 a0).trans_le ab) h.le)
state_before: case neg.H₃
a b : Ordinal.{u_1}
ab : a ≤ b
a0 : ¬a = 0
c : Ordinal.{u_1}
l : c.IsLimit
IH : ∀ o' < c, a ^ o' ≤ b ^ o'
⊢ a ^ c ≤ b ^ c
state_after: no goals
Theorem: Matroid.Base.map
File: Mathlib/Data/Matroid/Map.lean

tactic: rw [map_base_iff]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
B : Set α
hB : M.Base B
f : α → β
hf : InjOn f M.E
⊢ (M.map f hf).Base (f '' B)
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
B : Set α
hB : M.Base B
f : α → β
hf : InjOn f M.E
⊢ ∃ B₀, M.Base B₀ ∧ f '' B = f '' B₀

tactic: exact ⟨B, hB, rfl⟩
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
B : Set α
hB : M.Base B
f : α → β
hf : InjOn f M.E
⊢ ∃ B₀, M.Base B₀ ∧ f '' B = f '' B₀
state_after: no goals
Theorem: one_lt_star_iff
File: Mathlib/Algebra/Star/Order.lean

tactic: simpa using star_lt_star_iff (x := 1) (y := x)
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
x : R
⊢ 1 < star x ↔ 1 < x
state_after: no goals
Theorem: Nat.mem_primeFactors
File: Mathlib/Data/Nat/PrimeFin.lean

tactic: simp_rw [← toFinset_factors, List.mem_toFinset, mem_factors']
state_before: a b k m n p : ℕ
⊢ p ∈ n.primeFactors ↔ Prime p ∧ p ∣ n ∧ n ≠ 0
state_after: no goals
Theorem: Polynomial.leadingCoeff_map
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: simp only [← coeff_natDegree, coeff_map f, natDegree_map]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : DivisionRing R
p q : R[X]
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
⊢ (map f p).leadingCoeff = f p.leadingCoeff
state_after: no goals
Theorem: List.getElem?_modifyNth_eq
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp only [getElem?_modifyNth, if_pos]
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
⊢ (modifyNth f n l)[n]? = f <$> l[n]?
state_after: no goals
Theorem: PathConnectedSpace.exists_path_through_family'
File: Mathlib/Topology/Connected/PathConnected.lean

tactic: have : IsPathConnected (univ : Set X) := pathConnectedSpace_iff_univ.mp (by infer_instance)
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
⊢ ∃ γ t, ∀ (i : Fin (n + 1)), γ (t i) = p i
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
⊢ ∃ γ t, ∀ (i : Fin (n + 1)), γ (t i) = p i

tactic: rcases this.exists_path_through_family' p fun _i => True.intro with ⟨γ, t, -, h⟩
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
⊢ ∃ γ t, ∀ (i : Fin (n + 1)), γ (t i) = p i
state_after: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
γ : Path (p 0) (p ↑n)
t : Fin (n + 1) → ↑I
h : ∀ (i : Fin (n + 1)), γ (t i) = p i
⊢ ∃ γ t, ∀ (i : Fin (n + 1)), γ (t i) = p i

tactic: exact ⟨γ, t, h⟩
state_before: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
this : IsPathConnected univ
γ : Path (p 0) (p ↑n)
t : Fin (n + 1) → ↑I
h : ∀ (i : Fin (n + 1)), γ (t i) = p i
⊢ ∃ γ t, ∀ (i : Fin (n + 1)), γ (t i) = p i
state_after: no goals

tactic: infer_instance
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_3
F : Set X
inst✝ : PathConnectedSpace X
n : ℕ
p : Fin (n + 1) → X
⊢ PathConnectedSpace X
state_after: no goals
Theorem: AlgebraicGeometry.Spec.map_inj
File: Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean

tactic: rw [iff_comm, ← Quiver.Hom.op_inj.eq_iff, ← Scheme.Spec.map_injective.eq_iff]
state_before: R S : CommRingCat
φ ψ : R ⟶ S
f : Spec S ⟶ Spec R
⊢ map φ = map ψ ↔ φ = ψ
state_after: R S : CommRingCat
φ ψ : R ⟶ S
f : Spec S ⟶ Spec R
⊢ Scheme.Spec.map φ.op = Scheme.Spec.map ψ.op ↔ map φ = map ψ

tactic: rfl
state_before: R S : CommRingCat
φ ψ : R ⟶ S
f : Spec S ⟶ Spec R
⊢ Scheme.Spec.map φ.op = Scheme.Spec.map ψ.op ↔ map φ = map ψ
state_after: no goals
Theorem: MvPolynomial.eval₂Hom_congr
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: rintro rfl rfl rfl
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
f₁ f₂ : R →+* S₁
g₁ g₂ : σ → S₁
p₁ p₂ : MvPolynomial σ R
⊢ f₁ = f₂ → g₁ = g₂ → p₁ = p₂ → (eval₂Hom f₁ g₁) p₁ = (eval₂Hom f₂ g₂) p₂
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
f₁ : R →+* S₁
g₁ : σ → S₁
p₁ : MvPolynomial σ R
⊢ (eval₂Hom f₁ g₁) p₁ = (eval₂Hom f₁ g₁) p₁

tactic: rfl
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
f₁ : R →+* S₁
g₁ : σ → S₁
p₁ : MvPolynomial σ R
⊢ (eval₂Hom f₁ g₁) p₁ = (eval₂Hom f₁ g₁) p₁
state_after: no goals
Theorem: Nat.primeFactors_gcd
File: Mathlib/Data/Nat/PrimeFin.lean

tactic: ext
state_before: a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ (a.gcd b).primeFactors = a.primeFactors ∩ b.primeFactors
state_after: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ a✝ ∈ (a.gcd b).primeFactors ↔ a✝ ∈ a.primeFactors ∩ b.primeFactors

tactic: simp [dvd_gcd_iff, ha, hb, gcd_ne_zero_left ha]
state_before: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ a✝ ∈ (a.gcd b).primeFactors ↔ a✝ ∈ a.primeFactors ∩ b.primeFactors
state_after: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ Prime a✝ ∧ a✝ ∣ a ∧ a✝ ∣ b ↔ (Prime a✝ ∧ a✝ ∣ a) ∧ Prime a✝ ∧ a✝ ∣ b

tactic: aesop
state_before: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ Prime a✝ ∧ a✝ ∣ a ∧ a✝ ∣ b ↔ (Prime a✝ ∧ a✝ ∣ a) ∧ Prime a✝ ∧ a✝ ∣ b
state_after: no goals
Theorem: Complex.div_ratCast_re
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [div_ratCast]
state_before: z : ℂ
x : ℚ
⊢ (z / ↑x).re = z.re / ↑x
state_after: no goals
Theorem: List.TProd.elim_self
File: Mathlib/Data/Prod/TProd.lean

tactic: simp [TProd.elim]
state_before: ι : Type u
α : ι → Type v
i j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
v : TProd α (i :: l)
⊢ v.elim ⋯ = v.1
state_after: no goals
Theorem: lowerSemicontinuousAt_tsum
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp_rw [← lowerSemicontinuousWithinAt_univ_iff] at *
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type u_2
inst✝ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_3
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), LowerSemicontinuousAt (f i) x
⊢ LowerSemicontinuousAt (fun x' => ∑' (i : ι), f i x') x
state_after: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type u_2
inst✝ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_3
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), LowerSemicontinuousWithinAt (f i) univ x
⊢ LowerSemicontinuousWithinAt (fun x' => ∑' (i : ι), f i x') univ x

tactic: exact lowerSemicontinuousWithinAt_tsum h
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type u_2
inst✝ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_3
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), LowerSemicontinuousWithinAt (f i) univ x
⊢ LowerSemicontinuousWithinAt (fun x' => ∑' (i : ι), f i x') univ x
state_after: no goals
Theorem: NumberField.InfinitePlace.card_eq_card_isUnramifiedIn
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

tactic: rw [← card_isUnramified, ← card_isUnramified_compl, Finset.card_add_card_compl]
state_before: k : Type u_1
inst✝⁹ : Field k
K : Type u_2
inst✝⁸ : Field K
F : Type u_3
inst✝⁷ : Field F
inst✝⁶ : NumberField K
inst✝⁵ : Algebra k K
inst✝⁴ : Algebra k F
inst✝³ : Algebra K F
inst✝² : IsScalarTower k K F
σ : K ≃ₐ[k] K
w : InfinitePlace K
inst✝¹ : NumberField k
inst✝ : IsGalois k K
⊢ card (InfinitePlace K) =
    (Finset.filter (IsUnramifiedIn K) Finset.univ).card * finrank k K +
      (Finset.filter (IsUnramifiedIn K) Finset.univ)ᶜ.card * (finrank k K / 2)
state_after: no goals
Theorem: Complex.exists_cthickening_tendstoUniformlyOn
File: Mathlib/Analysis/Complex/LocallyUniformLimit.lean

tactic: obtain ⟨δ, hδ, hKδ⟩ := hK.exists_cthickening_subset_open hU hKU
state_before: E : Type u_1
ι : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hf : TendstoLocallyUniformlyOn F f φ U
hF : ∀ᶠ (n : ι) in φ, DifferentiableOn ℂ (F n) U
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
⊢ ∃ δ > 0, cthickening δ K ⊆ U ∧ TendstoUniformlyOn (deriv ∘ F) (cderiv δ f) φ K
state_after: case intro.intro
E : Type u_1
ι : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ✝ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hf : TendstoLocallyUniformlyOn F f φ U
hF : ∀ᶠ (n : ι) in φ, DifferentiableOn ℂ (F n) U
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
δ : ℝ
hδ : 0 < δ
hKδ : cthickening δ K ⊆ U
⊢ ∃ δ > 0, cthickening δ K ⊆ U ∧ TendstoUniformlyOn (deriv ∘ F) (cderiv δ f) φ K

tactic: exact ⟨δ, hδ, hKδ, tendstoUniformlyOn_deriv_of_cthickening_subset hf hF hδ hK hU hKδ⟩
state_before: case intro.intro
E : Type u_1
ι : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ✝ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hf : TendstoLocallyUniformlyOn F f φ U
hF : ∀ᶠ (n : ι) in φ, DifferentiableOn ℂ (F n) U
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
δ : ℝ
hδ : 0 < δ
hKδ : cthickening δ K ⊆ U
⊢ ∃ δ > 0, cthickening δ K ⊆ U ∧ TendstoUniformlyOn (deriv ∘ F) (cderiv δ f) φ K
state_after: no goals
Theorem: DFinsupp.filter_ne_eq_erase'
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: rw [← filter_ne_eq_erase f i]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
f : Π₀ (i : ι), β i
i : ι
⊢ filter (fun x => i ≠ x) f = erase i f
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
f : Π₀ (i : ι), β i
i : ι
⊢ filter (fun x => i ≠ x) f = filter (fun x => x ≠ i) f

tactic: congr with j
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
f : Π₀ (i : ι), β i
i : ι
⊢ filter (fun x => i ≠ x) f = filter (fun x => x ≠ i) f
state_after: case e_p.h.a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
f : Π₀ (i : ι), β i
i j : ι
⊢ i ≠ j ↔ j ≠ i

tactic: exact ne_comm
state_before: case e_p.h.a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
f : Π₀ (i : ι), β i
i j : ι
⊢ i ≠ j ↔ j ≠ i
state_after: no goals
Theorem: Cardinal.card_iUnion_lt_iff_forall_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: refine ⟨card_lt_of_card_iUnion_lt, fun h ↦ ?_⟩
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
ι α : Type u
t : ι → Set α
c : Cardinal.{u}
hc : c.IsRegular
hι : #ι < c
⊢ #↑(⋃ i, t i) < c ↔ ∀ (i : ι), #↑(t i) < c
state_after: α✝ : Type u_1
r : α✝ → α✝ → Prop
ι α : Type u
t : ι → Set α
c : Cardinal.{u}
hc : c.IsRegular
hι : #ι < c
h : ∀ (i : ι), #↑(t i) < c
⊢ #↑(⋃ i, t i) < c

tactic: apply lt_of_le_of_lt (Cardinal.mk_sUnion_le _)
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
ι α : Type u
t : ι → Set α
c : Cardinal.{u}
hc : c.IsRegular
hι : #ι < c
h : ∀ (i : ι), #↑(t i) < c
⊢ #↑(⋃ i, t i) < c
state_after: α✝ : Type u_1
r : α✝ → α✝ → Prop
ι α : Type u
t : ι → Set α
c : Cardinal.{u}
hc : c.IsRegular
hι : #ι < c
h : ∀ (i : ι), #↑(t i) < c
⊢ #↑(range fun i => t i) * ⨆ s, #↑↑s < c

tactic: apply Cardinal.mul_lt_of_lt hc.aleph0_le
  (lt_of_le_of_lt Cardinal.mk_range_le hι)
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
ι α : Type u
t : ι → Set α
c : Cardinal.{u}
hc : c.IsRegular
hι : #ι < c
h : ∀ (i : ι), #↑(t i) < c
⊢ #↑(range fun i => t i) * ⨆ s, #↑↑s < c
state_after: α✝ : Type u_1
r : α✝ → α✝ → Prop
ι α : Type u
t : ι → Set α
c : Cardinal.{u}
hc : c.IsRegular
hι : #ι < c
h : ∀ (i : ι), #↑(t i) < c
⊢ ⨆ s, #↑↑s < c

tactic: apply Cardinal.iSup_lt_of_isRegular hc (lt_of_le_of_lt Cardinal.mk_range_le hι)
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
ι α : Type u
t : ι → Set α
c : Cardinal.{u}
hc : c.IsRegular
hι : #ι < c
h : ∀ (i : ι), #↑(t i) < c
⊢ ⨆ s, #↑↑s < c
state_after: α✝ : Type u_1
r : α✝ → α✝ → Prop
ι α : Type u
t : ι → Set α
c : Cardinal.{u}
hc : c.IsRegular
hι : #ι < c
h : ∀ (i : ι), #↑(t i) < c
⊢ ∀ (i : ↑(range fun i => t i)), #↑↑i < c

tactic: simpa
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
ι α : Type u
t : ι → Set α
c : Cardinal.{u}
hc : c.IsRegular
hι : #ι < c
h : ∀ (i : ι), #↑(t i) < c
⊢ ∀ (i : ↑(range fun i => t i)), #↑↑i < c
state_after: no goals
Theorem: TopologicalGroup.of_nhds_one'
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rw [show (fun x => x₀ * x * x₀⁻¹) = (fun x => x * x₀⁻¹) ∘ fun x => x₀ * x from rfl, ←
  map_map, ← hleft, hright, map_map]
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Group G✝
inst✝³ : TopologicalGroup G✝
inst✝² : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u
inst✝¹ : Group G
inst✝ : TopologicalSpace G
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
hinv : Tendsto (fun x => x⁻¹) (𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : G), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
hright : ∀ (x₀ : G), 𝓝 x₀ = map (fun x => x * x₀) (𝓝 1)
x₀ : G
⊢ map (fun x => x₀ * x * x₀⁻¹) (𝓝 1) = 𝓝 1
state_after: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Group G✝
inst✝³ : TopologicalGroup G✝
inst✝² : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u
inst✝¹ : Group G
inst✝ : TopologicalSpace G
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
hinv : Tendsto (fun x => x⁻¹) (𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : G), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
hright : ∀ (x₀ : G), 𝓝 x₀ = map (fun x => x * x₀) (𝓝 1)
x₀ : G
⊢ map ((fun x => x * x₀⁻¹) ∘ fun x => x * x₀) (𝓝 1) = 𝓝 1
Theorem: Submodule.not_mem_of_ortho
File: Mathlib/Algebra/Module/Submodule/Basic.lean

tactic: intro hx
state_before: G : Type u''
S : Type u'
R : Type u
M : Type v
ι : Type w
inst✝³ : Ring R
inst✝² : IsDomain R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
x : M
N : Submodule R M
ortho : ∀ (c : R), ∀ y ∈ N, c • x + y = 0 → c = 0
⊢ x ∉ N
state_after: G : Type u''
S : Type u'
R : Type u
M : Type v
ι : Type w
inst✝³ : Ring R
inst✝² : IsDomain R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
x : M
N : Submodule R M
ortho : ∀ (c : R), ∀ y ∈ N, c • x + y = 0 → c = 0
hx : x ∈ N
⊢ False

tactic: simpa using ortho (-1) x hx
state_before: G : Type u''
S : Type u'
R : Type u
M : Type v
ι : Type w
inst✝³ : Ring R
inst✝² : IsDomain R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
x : M
N : Submodule R M
ortho : ∀ (c : R), ∀ y ∈ N, c • x + y = 0 → c = 0
hx : x ∈ N
⊢ False
state_after: no goals
Theorem: AlgebraicGeometry.IsAffineOpen.ιOpens_basicOpen_preimage
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

tactic: apply (Scheme.ιOpens (X.basicOpen r)).isAffineOpen_iff_of_isOpenImmersion.mp
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
r : ↑Γ(X, ⊤)
⊢ IsAffineOpen (Scheme.ιOpens (X.basicOpen r) ⁻¹ᵁ U)
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
r : ↑Γ(X, ⊤)
⊢ IsAffineOpen (Scheme.ιOpens (X.basicOpen r) ''ᵁ Scheme.ιOpens (X.basicOpen r) ⁻¹ᵁ U)

tactic: dsimp [Scheme.Hom.opensFunctor, LocallyRingedSpace.IsOpenImmersion.opensFunctor]
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
r : ↑Γ(X, ⊤)
⊢ IsAffineOpen (Scheme.ιOpens (X.basicOpen r) ''ᵁ Scheme.ιOpens (X.basicOpen r) ⁻¹ᵁ U)
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
r : ↑Γ(X, ⊤)
⊢ IsAffineOpen (⋯.functor.obj ((Opens.map (X.basicOpen r).inclusion).obj U))

tactic: rw [Opens.functor_obj_map_obj, Opens.openEmbedding_obj_top, inf_comm,
  ← Scheme.basicOpen_res _ _ (homOfLE le_top).op]
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
r : ↑Γ(X, ⊤)
⊢ IsAffineOpen (⋯.functor.obj ((Opens.map (X.basicOpen r).inclusion).obj U))
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
r : ↑Γ(X, ⊤)
⊢ IsAffineOpen (X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) r))

tactic: exact hU.basicOpen _
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
r : ↑Γ(X, ⊤)
⊢ IsAffineOpen (X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) r))
state_after: no goals