tasksource/leandojo huggingface dataset:
Theorem: Complex.integral_boundary_rect_eq_zero_of_differentiable_on_off_countable
File: Mathlib/Analysis/Complex/CauchyIntegral.lean

tactic: have : ∀ z, I • (fderiv ℂ f z).restrictScalars ℝ 1 = (fderiv ℂ f z).restrictScalars ℝ I := fun z ↦
  by rw [(fderiv ℂ f _).coe_restrictScalars', ← (fderiv ℂ f _).map_smul, smul_eq_mul, mul_one]
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
z w : ℂ
s : Set ℂ
hs : Set.Countable s
Hc : ContinuousOn f ([[z.re, w.re]] ×ℂ [[z.im, w.im]])
Hd :
  ∀ (x : ℂ), x ∈ Ioo (min z.re w.re) (max z.re w.re) ×ℂ Ioo (min z.im w.im) (max z.im w.im) \ s → DifferentiableAt ℂ f x
⊢ ((((∫ (x : ℝ) in z.re..w.re, f (↑x + ↑z.im * I)) - ∫ (x : ℝ) in z.re..w.re, f (↑x + ↑w.im * I)) +
        I • ∫ (y : ℝ) in z.im..w.im, f (↑w.re + ↑y * I)) -
      I • ∫ (y : ℝ) in z.im..w.im, f (↑z.re + ↑y * I)) =
    0

tactic: refine (integral_boundary_rect_of_hasFDerivAt_real_off_countable f
  (fun z => (fderiv ℂ f z).restrictScalars ℝ) z w s hs Hc
  (fun x hx => (Hd x hx).hasFDerivAt.restrictScalars ℝ) ?_).trans ?_ <;> simp [this]
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
z w : ℂ
s : Set ℂ
hs : Set.Countable s
Hc : ContinuousOn f ([[z.re, w.re]] ×ℂ [[z.im, w.im]])
Hd :
  ∀ (x : ℂ), x ∈ Ioo (min z.re w.re) (max z.re w.re) ×ℂ Ioo (min z.im w.im) (max z.im w.im) \ s → DifferentiableAt ℂ f x
this :
  ∀ (z : ℂ),
    I • ↑(ContinuousLinearMap.restrictScalars ℝ (fderiv ℂ f z)) 1 =
      ↑(ContinuousLinearMap.restrictScalars ℝ (fderiv ℂ f z)) I
⊢ ((((∫ (x : ℝ) in z.re..w.re, f (↑x + ↑z.im * I)) - ∫ (x : ℝ) in z.re..w.re, f (↑x + ↑w.im * I)) +
        I • ∫ (y : ℝ) in z.im..w.im, f (↑w.re + ↑y * I)) -
      I • ∫ (y : ℝ) in z.im..w.im, f (↑z.re + ↑y * I)) =
    0

tactic: rw [(fderiv ℂ f _).coe_restrictScalars', ← (fderiv ℂ f _).map_smul, smul_eq_mul, mul_one]
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
z✝ w : ℂ
s : Set ℂ
hs : Set.Countable s
Hc : ContinuousOn f ([[z✝.re, w.re]] ×ℂ [[z✝.im, w.im]])
Hd :
  ∀ (x : ℂ),
    x ∈ Ioo (min z✝.re w.re) (max z✝.re w.re) ×ℂ Ioo (min z✝.im w.im) (max z✝.im w.im) \ s → DifferentiableAt ℂ f x
z : ℂ
⊢ I • ↑(ContinuousLinearMap.restrictScalars ℝ (fderiv ℂ f z)) 1 =
    ↑(ContinuousLinearMap.restrictScalars ℝ (fderiv ℂ f z)) I
Theorem: Submodule.span_neg
File: Mathlib/LinearAlgebra/Span.lean

tactic: simp
state_before: R : Type u_2
R₂ : Type ?u.274344
K : Type ?u.274347
M : Type u_1
M₂ : Type ?u.274353
V : Type ?u.274356
S : Type ?u.274359
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ span R (-s) = span R (↑(-LinearMap.id) '' s)

tactic: simp
state_before: R : Type u_2
R₂ : Type ?u.274344
K : Type ?u.274347
M : Type u_1
M₂ : Type ?u.274353
V : Type ?u.274356
S : Type ?u.274359
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
s : Set M
⊢ map (-LinearMap.id) (span R s) = span R s
Theorem: FirstOrder.Language.Formula.realize_relabel
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Realize, Realize, relabel, BoundedFormula.realize_relabel, iff_eq_eq, Fin.castAdd_zero]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.238835
P : Type ?u.238838
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ✝ ψ : Formula L α
v✝ : α → M
φ : Formula L α
g : α → β
v : β → M
⊢ Realize (relabel g φ) v ↔ Realize φ (v ∘ g)

tactic: exact congr rfl (funext finZeroElim)
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.238835
P : Type ?u.238838
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ✝ ψ : Formula L α
v✝ : α → M
φ : Formula L α
g : α → β
v : β → M
⊢ BoundedFormula.Realize φ (Sum.elim v (default ∘ ↑(Fin.cast (_ : 0 = 0))) ∘ Sum.inl ∘ g) (default ∘ ↑(natAdd 0)) =
    BoundedFormula.Realize φ (v ∘ g) default
Theorem: SimpleGraph.map_comap_le
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rw [map_le_iff_le_comap]
state_before: ι : Sort ?u.249498
𝕜 : Type ?u.249501
V : Type u
W : Type v
X : Type w
G✝ : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
f : V ↪ W
G : SimpleGraph W
⊢ SimpleGraph.map f (SimpleGraph.comap (↑f) G) ≤ G
Theorem: Nat.add_descFactorial_eq_ascFactorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [ascFactorial_zero, descFactorial_zero]
state_before: n : ℕ
⊢ descFactorial (n + 0) 0 = ascFactorial n 0

tactic: rw [Nat.add_succ, Nat.succ_eq_add_one, Nat.succ_eq_add_one,
    succ_descFactorial_succ, ascFactorial_succ, add_descFactorial_eq_ascFactorial _ k]
state_before: n k : ℕ
⊢ descFactorial (n + succ k) (succ k) = ascFactorial n (succ k)
Theorem: AddCommGroup.not_modEq_iff_ne_add_zsmul
File: Mathlib/Algebra/ModEq.lean

tactic: rw [modEq_iff_eq_add_zsmul, not_exists]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ ¬a ≡ b [PMOD p] ↔ ∀ (z : ℤ), b ≠ a + z • p
Theorem: PadicInt.limNthHom_zero
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: simp [limNthHom]
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
f : (k : ℕ) → R →+* ZMod (p ^ k)
f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), RingHom.comp (ZMod.castHom (_ : p ^ k1 ∣ p ^ k2) (ZMod (p ^ k1))) (f k2) = f k1
⊢ limNthHom f_compat 0 = 0

tactic: rfl
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type u_1
inst✝ : NonAssocSemiring R
f : (k : ℕ) → R →+* ZMod (p ^ k)
f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), RingHom.comp (ZMod.castHom (_ : p ^ k1 ∣ p ^ k2) (ZMod (p ^ k1))) (f k2) = f k1
⊢ ofIntSeq 0 (_ : IsCauSeq (padicNorm p) fun n => ↑(OfNat.ofNat 0 n)) = 0
Theorem: Set.image_multiset_prod
File: Mathlib/Data/Set/Pointwise/BigOperators.lean

tactic: simpa only [Multiset.quot_mk_to_coe, Multiset.coe_prod, Multiset.coe_map] using
  image_list_prod f
state_before: ι : Type ?u.19659
α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f : F
⊢ ∀ (a : List (Set α)),
    ↑f '' Multiset.prod (Quotient.mk (List.isSetoid (Set α)) a) =
      Multiset.prod (Multiset.map (fun s => ↑f '' s) (Quotient.mk (List.isSetoid (Set α)) a))
Theorem: Nat.ord_compl_of_not_prime
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [factorization_eq_zero_of_non_prime n hp]
state_before: n p : ℕ
hp : ¬Prime p
⊢ n / p ^ ↑(factorization n) p = n
Theorem: IsPGroup.iff_orderOf
File: Mathlib/GroupTheory/PGroup.lean

tactic: rw [← hk, pow_orderOf_eq_one]
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
hp : Fact (Nat.Prime p)
g : G
k : ℕ
hk : orderOf g = p ^ k
⊢ g ^ p ^ k = 1
Theorem: or_or_or_comm
File: Std/Logic.lean

tactic: rw [← or_assoc, @or_right_comm a, or_assoc]
state_before: a b c d : Prop
⊢ (a ∨ b) ∨ c ∨ d ↔ (a ∨ c) ∨ b ∨ d
Theorem: IsFreeGroupoid.SpanningTree.loopOfHom_eq_id
File: Mathlib/GroupTheory/NielsenSchreier.lean

tactic: rw [loopOfHom, ← Category.assoc, IsIso.comp_inv_eq, Category.id_comp]
state_before: G : Type u
inst✝² : Groupoid G
inst✝¹ : IsFreeGroupoid G
T : WideSubquiver (Symmetrify (Generators G))
inst✝ : Arborescence (WideSubquiver.toType (Symmetrify (Generators G)) T)
a b : Generators G
e : a ⟶ b
H : e ∈ wideSubquiverSymmetrify T a b
⊢ loopOfHom T (of e) = 𝟙 (IsFreeGroupoid.SpanningTree.root' T)

tactic: cases' H with H H
state_before: G : Type u
inst✝² : Groupoid G
inst✝¹ : IsFreeGroupoid G
T : WideSubquiver (Symmetrify (Generators G))
inst✝ : Arborescence (WideSubquiver.toType (Symmetrify (Generators G)) T)
a b : Generators G
e : a ⟶ b
H : e ∈ wideSubquiverSymmetrify T a b
⊢ treeHom T
        (let_fun this := a;
        this) ≫
      of e =
    treeHom T b

tactic: rw [treeHom_eq T (Path.cons default ⟨Sum.inl e, H⟩), homOfPath]
state_before: case inl
G : Type u
inst✝² : Groupoid G
inst✝¹ : IsFreeGroupoid G
T : WideSubquiver (Symmetrify (Generators G))
inst✝ : Arborescence (WideSubquiver.toType (Symmetrify (Generators G)) T)
a b : Generators G
e : a ⟶ b
H : T a b (Sum.inl e)
⊢ treeHom T
        (let_fun this := a;
        this) ≫
      of e =
    treeHom T b

tactic: rfl
state_before: case inl
G : Type u
inst✝² : Groupoid G
inst✝¹ : IsFreeGroupoid G
T : WideSubquiver (Symmetrify (Generators G))
inst✝ : Arborescence (WideSubquiver.toType (Symmetrify (Generators G)) T)
a b : Generators G
e : a ⟶ b
H : T a b (Sum.inl e)
⊢ treeHom T
        (let_fun this := a;
        this) ≫
      of e =
    homOfPath T default ≫ Sum.recOn (↑{ val := Sum.inl e, property := H }) (fun e => of e) fun e => inv (of e)

tactic: rw [treeHom_eq T (Path.cons default ⟨Sum.inr e, H⟩), homOfPath]
state_before: case inr
G : Type u
inst✝² : Groupoid G
inst✝¹ : IsFreeGroupoid G
T : WideSubquiver (Symmetrify (Generators G))
inst✝ : Arborescence (WideSubquiver.toType (Symmetrify (Generators G)) T)
a b : Generators G
e : a ⟶ b
H : T b a (Sum.inr e)
⊢ treeHom T
        (let_fun this := a;
        this) ≫
      of e =
    treeHom T b

tactic: simp only [IsIso.inv_hom_id, Category.comp_id, Category.assoc, treeHom]
state_before: case inr
G : Type u
inst✝² : Groupoid G
inst✝¹ : IsFreeGroupoid G
T : WideSubquiver (Symmetrify (Generators G))
inst✝ : Arborescence (WideSubquiver.toType (Symmetrify (Generators G)) T)
a b : Generators G
e : a ⟶ b
H : T b a (Sum.inr e)
⊢ (homOfPath T default ≫ Sum.recOn (↑{ val := Sum.inr e, property := H }) (fun e => of e) fun e => inv (of e)) ≫ of e =
    treeHom T b
Theorem: BddBelow.image2_bddAbove
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
⊢ BddBelow s → BddBelow t → BddAbove (Set.image2 f s t)

tactic: exact ⟨f a b, mem_upperBounds_image2_of_mem_lowerBounds h₀ h₁ ha hb⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
ha : a ∈ lowerBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddAbove (Set.image2 f s t)
Theorem: Fin.insertNth_zero'
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [insertNth_zero]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : β
p : Fin n → β
⊢ insertNth 0 x p = cons x p
Theorem: ContinuousMap.continuous_comp_left
File: Mathlib/Topology/CompactOpen.lean

tactic: rw [hm, image_gen f hs hu]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
g : C(β, γ)
f : C(α, β)
m : Set C(α, γ)
x✝ : m ∈ {m | ∃ s x u x, m = CompactOpen.gen s u}
s : Set α
hs : IsCompact s
u : Set γ
hu : IsOpen u
hm : m = CompactOpen.gen s u
⊢ IsOpen ((fun g => comp g f) ⁻¹' m)

tactic: exact ContinuousMap.isOpen_gen (hs.image f.2) hu
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
g : C(β, γ)
f : C(α, β)
m : Set C(α, γ)
x✝ : m ∈ {m | ∃ s x u x, m = CompactOpen.gen s u}
s : Set α
hs : IsCompact s
u : Set γ
hu : IsOpen u
hm : m = CompactOpen.gen s u
⊢ IsOpen (CompactOpen.gen (↑f '' s) u)
Theorem: Order.Ioo_succ_right_eq_insert_of_not_isMax
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp_rw [← Iio_inter_Ioi, Iio_succ_eq_insert_of_not_isMax h₂, insert_inter_of_mem (mem_Ioi.2 h₁)]
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
h₁ : a < b
h₂ : ¬IsMax b
⊢ Ioo a (succ b) = insert b (Ioo a b)
Theorem: CategoryTheory.ite_comp
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: aesop
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
P : Prop
inst✝ : Decidable P
X Y Z : C
f f' : X ⟶ Y
g : Y ⟶ Z
⊢ (if P then f else f') ≫ g = if P then f ≫ g else f' ≫ g
Theorem: ZNum.cast_mul
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_int, mul_to_int, Int.cast_mul, cast_to_int, cast_to_int]
state_before: α : Type u_1
inst✝ : Ring α
m n : ZNum
⊢ ↑(m * n) = ↑m * ↑n
Theorem: Subsemiring.top_prod
File: Mathlib/RingTheory/Subsemiring/Basic.lean

tactic: simp [mem_prod, MonoidHom.coe_snd]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
s : Subsemiring S
x : R × S
⊢ x ∈ prod ⊤ s ↔ x ∈ comap (RingHom.snd R S) s
Theorem: IsSquare.pow
File: Mathlib/Algebra/Parity.lean

tactic: rintro ⟨a, rfl⟩
state_before: F : Type ?u.8146
α : Type u_1
β : Type ?u.8152
R : Type ?u.8155
inst✝ : Monoid α
n✝ : ℕ
a : α
n : ℕ
⊢ IsSquare a → IsSquare (a ^ n)

tactic: exact ⟨a ^ n, (Commute.refl _).mul_pow _⟩
state_before: case intro
F : Type ?u.8146
α : Type u_1
β : Type ?u.8152
R : Type ?u.8155
inst✝ : Monoid α
n✝ n : ℕ
a : α
⊢ IsSquare ((a * a) ^ n)
Theorem: MvPFunctor.M.dest_corec
File: Mathlib/Data/PFunctor/Multivariate/M.lean

tactic: trans
state_before: n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
β : Type u
g : β → Obj P (α ::: β)
x : β
⊢ dest P (corec P g x) = (TypeVec.id ::: corec P g) <$$> g x

tactic: apply M.dest_corec'
state_before: n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
β : Type u
g : β → Obj P (α ::: β)
x : β
⊢ dest P (corec P g x) = ?m.38931

n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
β : Type u
g : β → Obj P (α ::: β)
x : β
⊢ ?m.38931 = (TypeVec.id ::: corec P g) <$$> g x

n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
β : Type u
g : β → Obj P (α ::: β)
x : β
⊢ Obj P (α ::: M P α)

tactic: cases' g x with a f
state_before: n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
β : Type u
g : β → Obj P (α ::: β)
x : β
⊢ { fst := (g x).fst,
      snd :=
        splitFun (dropFun (g x).snd)
          ((corec' P (fun b => (g b).fst) (fun b => dropFun (g b).snd) fun b => lastFun (g b).snd) ∘
            lastFun (g x).snd) } =
    (TypeVec.id ::: corec P g) <$$> g x

tactic: dsimp
state_before: case mk
n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
β : Type u
g : β → Obj P (α ::: β)
x : β
a : P.A
f : B P a ⟹ α ::: β
⊢ { fst := { fst := a, snd := f }.fst,
      snd :=
        splitFun (dropFun { fst := a, snd := f }.snd)
          ((corec' P (fun b => (g b).fst) (fun b => dropFun (g b).snd) fun b => lastFun (g b).snd) ∘
            lastFun { fst := a, snd := f }.snd) } =
    (TypeVec.id ::: corec P g) <$$> { fst := a, snd := f }

tactic: rw [MvPFunctor.map_eq]
state_before: case mk
n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
β : Type u
g : β → Obj P (α ::: β)
x : β
a : P.A
f : B P a ⟹ α ::: β
⊢ { fst := a,
      snd :=
        splitFun (dropFun f)
          ((corec' P (fun b => (g b).fst) (fun b => dropFun (g b).snd) fun b => lastFun (g b).snd) ∘ lastFun f) } =
    (TypeVec.id ::: corec P g) <$$> { fst := a, snd := f }

tactic: congr
state_before: case mk
n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
β : Type u
g : β → Obj P (α ::: β)
x : β
a : P.A
f : B P a ⟹ α ::: β
⊢ { fst := a,
      snd :=
        splitFun (dropFun f)
          ((corec' P (fun b => (g b).fst) (fun b => dropFun (g b).snd) fun b => lastFun (g b).snd) ∘ lastFun f) } =
    { fst := a, snd := (TypeVec.id ::: corec P g) ⊚ f }

tactic: conv =>
  rhs
  rw [← split_dropFun_lastFun f, appendFun_comp_splitFun]
state_before: case mk.e_snd
n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
β : Type u
g : β → Obj P (α ::: β)
x : β
a : P.A
f : B P a ⟹ α ::: β
⊢ splitFun (dropFun f)
      ((corec' P (fun b => (g b).fst) (fun b => dropFun (g b).snd) fun b => lastFun (g b).snd) ∘ lastFun f) =
    (TypeVec.id ::: corec P g) ⊚ f
Theorem: MeasureTheory.Measure.pi_pi
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: haveI : Encodable ι := Fintype.toEncodable ι
state_before: ι : Type u_2
ι' : Type ?u.3051144
α : ι → Type u_1
inst✝² : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝¹ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝ : ∀ (i : ι), SigmaFinite (μ i)
s : (i : ι) → Set (α i)
⊢ ↑↑(Measure.pi μ) (Set.pi univ s) = ∏ i : ι, ↑↑(μ i) (s i)

tactic: rw [← pi'_eq_pi, pi'_pi]
state_before: ι : Type u_2
ι' : Type ?u.3051144
α : ι → Type u_1
inst✝² : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝¹ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝ : ∀ (i : ι), SigmaFinite (μ i)
s : (i : ι) → Set (α i)
this : Encodable ι
⊢ ↑↑(Measure.pi μ) (Set.pi univ s) = ∏ i : ι, ↑↑(μ i) (s i)
Theorem: separated_def'
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: rw [← not_imp_not]
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
x y : α
⊢ (∀ (r : Set (α × α)), r ∈ 𝓤 α → (x, y) ∈ r) → x = y ↔ x ≠ y → ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r

tactic: simp [not_forall]
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
x y : α
⊢ (¬x = y → ¬∀ (r : Set (α × α)), r ∈ 𝓤 α → (x, y) ∈ r) ↔ x ≠ y → ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r
Theorem: CategoryTheory.Adjunction.map_injective
File: Mathlib/CategoryTheory/Preadditive/Injective.lean

tactic: intro
state_before: C : Type u₁
inst✝² : Category C
D : Type u_2
inst✝¹ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝ : Functor.PreservesMonomorphisms F
I : D
hI : Injective I
X Y : C
f : X ⟶ G.obj I
g : X ⟶ Y
⊢ ∀ [inst : Mono g], ∃ h, g ≫ h = f

tactic: rcases hI.factors (F.map f ≫ adj.counit.app _) (F.map g) with ⟨w,h⟩
state_before: C : Type u₁
inst✝³ : Category C
D : Type u_2
inst✝² : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝¹ : Functor.PreservesMonomorphisms F
I : D
hI : Injective I
X Y : C
f : X ⟶ G.obj I
g : X ⟶ Y
inst✝ : Mono g
⊢ ∃ h, g ≫ h = f

tactic: use adj.unit.app Y ≫ G.map w
state_before: case intro
C : Type u₁
inst✝³ : Category C
D : Type u_2
inst✝² : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝¹ : Functor.PreservesMonomorphisms F
I : D
hI : Injective I
X Y : C
f : X ⟶ G.obj I
g : X ⟶ Y
inst✝ : Mono g
w : F.obj Y ⟶ I
h : F.map g ≫ w = F.map f ≫ adj.counit.app I
⊢ ∃ h, g ≫ h = f

tactic: rw [← unit_naturality_assoc, ← G.map_comp, h]
state_before: case intro
C : Type u₁
inst✝³ : Category C
D : Type u_2
inst✝² : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝¹ : Functor.PreservesMonomorphisms F
I : D
hI : Injective I
X Y : C
f : X ⟶ G.obj I
g : X ⟶ Y
inst✝ : Mono g
w : F.obj Y ⟶ I
h : F.map g ≫ w = F.map f ≫ adj.counit.app I
⊢ g ≫ adj.unit.app Y ≫ G.map w = f

tactic: simp
state_before: case intro
C : Type u₁
inst✝³ : Category C
D : Type u_2
inst✝² : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝¹ : Functor.PreservesMonomorphisms F
I : D
hI : Injective I
X Y : C
f : X ⟶ G.obj I
g : X ⟶ Y
inst✝ : Mono g
w : F.obj Y ⟶ I
h : F.map g ≫ w = F.map f ≫ adj.counit.app I
⊢ adj.unit.app X ≫ G.map (F.map f ≫ adj.counit.app I) = f
Theorem: HahnSeries.support_nonempty_iff
File: Mathlib/RingTheory/HahnSeries.lean

tactic: rw [support, support_nonempty_iff, Ne.def, coeff_fun_eq_zero_iff]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
x : HahnSeries Γ R
⊢ Set.Nonempty (support x) ↔ x ≠ 0
Theorem: IsCyclic.card_orderOf_eq_totient
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: classical apply card_orderOf_eq_totient_aux₂ (fun n => IsCyclic.card_pow_eq_one_le) hd
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : IsCyclic α
inst✝ : Fintype α
d : ℕ
hd : d ∣ Fintype.card α
⊢ card (filter (fun a => orderOf a = d) univ) = φ d

tactic: apply card_orderOf_eq_totient_aux₂ (fun n => IsCyclic.card_pow_eq_one_le) hd
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : IsCyclic α
inst✝ : Fintype α
d : ℕ
hd : d ∣ Fintype.card α
⊢ card (filter (fun a => orderOf a = d) univ) = φ d
Theorem: Dfinsupp.support_rangeIcc_subset
File: Mathlib/Data/Dfinsupp/Interval.lean

tactic: refine' fun x hx => _
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : (i : ι) → Zero (α i)
inst✝³ : (i : ι) → PartialOrder (α i)
inst✝² : (i : ι) → LocallyFiniteOrder (α i)
f g : Π₀ (i : ι), α i
i : ι
a : α i
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
⊢ support (rangeIcc f g) ⊆ support f ∪ support g

tactic: by_contra h
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : (i : ι) → Zero (α i)
inst✝³ : (i : ι) → PartialOrder (α i)
inst✝² : (i : ι) → LocallyFiniteOrder (α i)
f g : Π₀ (i : ι), α i
i : ι
a : α i
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
x : ι
hx : x ∈ support (rangeIcc f g)
⊢ x ∈ support f ∪ support g

tactic: refine' not_mem_support_iff.2 _ hx
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : (i : ι) → Zero (α i)
inst✝³ : (i : ι) → PartialOrder (α i)
inst✝² : (i : ι) → LocallyFiniteOrder (α i)
f g : Π₀ (i : ι), α i
i : ι
a : α i
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
x : ι
hx : x ∈ support (rangeIcc f g)
h : ¬x ∈ support f ∪ support g
⊢ False

tactic: rw [rangeIcc_apply, not_mem_support_iff.1 (not_mem_mono (subset_union_left _ _) h),
  not_mem_support_iff.1 (not_mem_mono (subset_union_right _ _) h)]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : (i : ι) → Zero (α i)
inst✝³ : (i : ι) → PartialOrder (α i)
inst✝² : (i : ι) → LocallyFiniteOrder (α i)
f g : Π₀ (i : ι), α i
i : ι
a : α i
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
x : ι
hx : x ∈ support (rangeIcc f g)
h : ¬x ∈ support f ∪ support g
⊢ ↑(rangeIcc f g) x = 0

tactic: exact Icc_self _
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : (i : ι) → Zero (α i)
inst✝³ : (i : ι) → PartialOrder (α i)
inst✝² : (i : ι) → LocallyFiniteOrder (α i)
f g : Π₀ (i : ι), α i
i : ι
a : α i
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
x : ι
hx : x ∈ support (rangeIcc f g)
h : ¬x ∈ support f ∪ support g
⊢ Icc 0 0 = 0
Theorem: Finset.card_Ico_finset
File: Mathlib/Data/Finset/Interval.lean

tactic: rw [card_Ico_eq_card_Icc_sub_one, card_Icc_finset h]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
⊢ card (Ico s t) = 2 ^ (card t - card s) - 1
Theorem: Bool.or_inr
File: Mathlib/Data/Bool/Basic.lean

tactic: cases a <;> simp [H]
state_before: a b : Bool
H : b = true
⊢ (a || b) = true
Theorem: vsub_self
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [← zero_add (p -ᵥ p), ← vadd_vsub_assoc, vadd_vsub]
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
p : P
⊢ p -ᵥ p = 0
Theorem: Finite.card_le_of_injective
File: Mathlib/Data/Finite/Card.lean

tactic: haveI := Fintype.ofFinite β
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.2279
inst✝ : Finite β
f : α → β
hf : Function.Injective f
⊢ Nat.card α ≤ Nat.card β

tactic: haveI := Fintype.ofInjective f hf
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.2279
inst✝ : Finite β
f : α → β
hf : Function.Injective f
this : Fintype β
⊢ Nat.card α ≤ Nat.card β

tactic: simpa only [Nat.card_eq_fintype_card, ge_iff_le] using Fintype.card_le_of_injective f hf
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.2279
inst✝ : Finite β
f : α → β
hf : Function.Injective f
this✝ : Fintype β
this : Fintype α
⊢ Nat.card α ≤ Nat.card β
Theorem: Finset.weightedVSubOfPoint_eq_of_sum_eq_zero
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: apply eq_of_sub_eq_zero
state_before: k : Type u_1
V : Type u_3
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.31556
s₂ : Finset ι₂
w : ι → k
p : ι → P
h : ∑ i in s, w i = 0
b₁ b₂ : P
⊢ ↑(weightedVSubOfPoint s p b₁) w = ↑(weightedVSubOfPoint s p b₂) w

tactic: rw [weightedVSubOfPoint_apply, weightedVSubOfPoint_apply, ← sum_sub_distrib]
state_before: case h
k : Type u_1
V : Type u_3
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.31556
s₂ : Finset ι₂
w : ι → k
p : ι → P
h : ∑ i in s, w i = 0
b₁ b₂ : P
⊢ ↑(weightedVSubOfPoint s p b₁) w - ↑(weightedVSubOfPoint s p b₂) w = 0

tactic: rw [← sum_smul, h, zero_smul]
state_before: case h
k : Type u_1
V : Type u_3
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.31556
s₂ : Finset ι₂
w : ι → k
p : ι → P
h : ∑ i in s, w i = 0
b₁ b₂ : P
⊢ ∑ x in s, w x • (b₂ -ᵥ b₁) = 0