tasksource/leandojo huggingface dataset:
Theorem: SymplecticGroup.coe_inv'
File: Mathlib/LinearAlgebra/SymplecticGroup.lean

tactic: refine' (coe_inv A).trans (inv_eq_left_inv _).symm
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A✝ : Matrix (l ⊕ l) (l ⊕ l) R
A : { x // x ∈ symplecticGroup l R }
⊢ ↑A⁻¹ = (↑A)⁻¹

tactic: simp [inv_left_mul_aux, coe_inv]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A✝ : Matrix (l ⊕ l) (l ⊕ l) R
A : { x // x ∈ symplecticGroup l R }
⊢ (-J l R) ⬝ (↑A)ᵀ ⬝ J l R ⬝ ↑A = 1
Theorem: card_vector
File: Mathlib/Data/Fintype/BigOperators.lean

tactic: rw [Fintype.ofEquiv_card]
state_before: α : Type u_1
β : Type ?u.13103
γ : Type ?u.13106
inst✝ : Fintype α
n : ℕ
⊢ Fintype.card (Vector α n) = Fintype.card α ^ n

tactic: simp
state_before: α : Type u_1
β : Type ?u.13103
γ : Type ?u.13106
inst✝ : Fintype α
n : ℕ
⊢ Fintype.card (Fin n → α) = Fintype.card α ^ n
Theorem: IsTorsion.extension_closed
File: Mathlib/GroupTheory/Torsion.lean

tactic: obtain ⟨ngn, ngnpos, hngn⟩ := (isOfFinOrder_iff_pow_eq_one _).mp (tH <| f g)
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Group G
N : Subgroup G
inst✝ : Group H
f : G →* H
hN : N = MonoidHom.ker f
tH : IsTorsion H
tN : IsTorsion { x // x ∈ N }
g : G
⊢ ∃ n, 0 < n ∧ g ^ n = 1

tactic: have hmem := f.mem_ker.mpr ((f.map_pow g ngn).trans hngn)
state_before: case intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Group G
N : Subgroup G
inst✝ : Group H
f : G →* H
hN : N = MonoidHom.ker f
tH : IsTorsion H
tN : IsTorsion { x // x ∈ N }
g : G
ngn : ℕ
ngnpos : 0 < ngn
hngn : ↑f g ^ ngn = 1
⊢ ∃ n, 0 < n ∧ g ^ n = 1

tactic: lift g ^ ngn to N using hN.symm ▸ hmem with gn h
state_before: case intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Group G
N : Subgroup G
inst✝ : Group H
f : G →* H
hN : N = MonoidHom.ker f
tH : IsTorsion H
tN : IsTorsion { x // x ∈ N }
g : G
ngn : ℕ
ngnpos : 0 < ngn
hngn : ↑f g ^ ngn = 1
hmem : g ^ ngn ∈ MonoidHom.ker f
⊢ ∃ n, 0 < n ∧ g ^ n = 1

tactic: obtain ⟨nn, nnpos, hnn⟩ := (isOfFinOrder_iff_pow_eq_one _).mp (tN gn)
state_before: case intro.intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Group G
N : Subgroup G
inst✝ : Group H
f : G →* H
hN : N = MonoidHom.ker f
tH : IsTorsion H
tN : IsTorsion { x // x ∈ N }
g : G
ngn : ℕ
ngnpos : 0 < ngn
hngn : ↑f g ^ ngn = 1
gn : { x // x ∈ N }
h : ↑gn = g ^ ngn
hmem✝ hmem : ↑gn ∈ MonoidHom.ker f
⊢ ∃ n, 0 < n ∧ g ^ n = 1

tactic: exact
  ⟨ngn * nn, mul_pos ngnpos nnpos, by
    rw [pow_mul, ← h, ← Subgroup.coe_pow, hnn, Subgroup.coe_one]⟩
state_before: case intro.intro.intro.intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Group G
N : Subgroup G
inst✝ : Group H
f : G →* H
hN : N = MonoidHom.ker f
tH : IsTorsion H
tN : IsTorsion { x // x ∈ N }
g : G
ngn : ℕ
ngnpos : 0 < ngn
hngn : ↑f g ^ ngn = 1
gn : { x // x ∈ N }
h : ↑gn = g ^ ngn
hmem✝ hmem : ↑gn ∈ MonoidHom.ker f
nn : ℕ
nnpos : 0 < nn
hnn : gn ^ nn = 1
⊢ ∃ n, 0 < n ∧ g ^ n = 1

tactic: rw [pow_mul, ← h, ← Subgroup.coe_pow, hnn, Subgroup.coe_one]
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Group G
N : Subgroup G
inst✝ : Group H
f : G →* H
hN : N = MonoidHom.ker f
tH : IsTorsion H
tN : IsTorsion { x // x ∈ N }
g : G
ngn : ℕ
ngnpos : 0 < ngn
hngn : ↑f g ^ ngn = 1
gn : { x // x ∈ N }
h : ↑gn = g ^ ngn
hmem✝ hmem : ↑gn ∈ MonoidHom.ker f
nn : ℕ
nnpos : 0 < nn
hnn : gn ^ nn = 1
⊢ g ^ (ngn * nn) = 1
Theorem: SeparationQuotient.isOpenMap_mk
File: Mathlib/Topology/Inseparable.lean

tactic: rwa [preimage_image_mk_open hs]
state_before: X : Type u_1
Y : Type ?u.48723
Z : Type ?u.48726
α : Type ?u.48729
ι : Type ?u.48732
π : ι → Type ?u.48737
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s✝ : Set X
f : X → Y
t : Set (SeparationQuotient X)
s : Set X
hs : IsOpen s
⊢ IsOpen (mk ⁻¹' (mk '' s))
Theorem: Real.Angle.arg_expMapCircle
File: Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ ↑(arg ↑(expMapCircle θ)) = θ

tactic: rw [Real.Angle.expMapCircle_coe, expMapCircle_apply, exp_mul_I, ← ofReal_cos, ← ofReal_sin, ←
  Real.Angle.cos_coe, ← Real.Angle.sin_coe, arg_cos_add_sin_mul_I_coe_angle]
state_before: case h
x✝ : ℝ
⊢ ↑(arg ↑(expMapCircle ↑x✝)) = ↑x✝
Theorem: Finset.image_mul_right'
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp
state_before: F : Type ?u.626033
α : Type u_1
β : Type ?u.626039
γ : Type ?u.626042
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : DivisionMonoid β
inst✝ : MonoidHomClass F α β
f : F
s t : Finset α
a b : α
⊢ image (fun x => x * b⁻¹) t = preimage t (fun x => x * b) (_ : Set.InjOn (fun x => x * b) ((fun x => x * b) ⁻¹' ↑t))
Theorem: Module.End.IsNilpotent.mapQ
File: Mathlib/RingTheory/Nilpotent.lean

tactic: obtain ⟨k, hk⟩ := hnp
state_before: R S : Type u
x y : R
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : End R M
p : Submodule R M
hp : p ≤ Submodule.comap f p
hnp : IsNilpotent f
⊢ IsNilpotent (Submodule.mapQ p p f hp)

tactic: use k
state_before: case intro
R S : Type u
x y : R
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : End R M
p : Submodule R M
hp : p ≤ Submodule.comap f p
k : ℕ
hk : f ^ k = 0
⊢ IsNilpotent (Submodule.mapQ p p f hp)

tactic: simp [← p.mapQ_pow, hk]
state_before: case intro
R S : Type u
x y : R
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : End R M
p : Submodule R M
hp : p ≤ Submodule.comap f p
k : ℕ
hk : f ^ k = 0
⊢ Submodule.mapQ p p f hp ^ k = 0
Theorem: UniformInducing.uniformEquicontinuous_iff
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: have := UniformFun.postcomp_uniformInducing (α := ι) hu
state_before: ι : Type u_3
κ : Type ?u.130947
X : Type ?u.130950
Y : Type ?u.130953
Z : Type ?u.130956
α : Type u_1
β : Type u_4
γ : Type u_2
𝓕 : Type ?u.130968
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → β → α
u : α → γ
hu : UniformInducing u
⊢ UniformEquicontinuous F ↔ UniformEquicontinuous ((fun x x_1 => x ∘ x_1) u ∘ F)

tactic: rw [uniformEquicontinuous_iff_uniformContinuous, uniformEquicontinuous_iff_uniformContinuous,
  this.uniformContinuous_iff]
state_before: ι : Type u_3
κ : Type ?u.130947
X : Type ?u.130950
Y : Type ?u.130953
Z : Type ?u.130956
α : Type u_1
β : Type u_4
γ : Type u_2
𝓕 : Type ?u.130968
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → β → α
u : α → γ
hu : UniformInducing u
this : UniformInducing (↑UniformFun.ofFun ∘ (fun x => u ∘ x) ∘ ↑toFun)
⊢ UniformEquicontinuous F ↔ UniformEquicontinuous ((fun x x_1 => x ∘ x_1) u ∘ F)

tactic: rfl
state_before: ι : Type u_3
κ : Type ?u.130947
X : Type ?u.130950
Y : Type ?u.130953
Z : Type ?u.130956
α : Type u_1
β : Type u_4
γ : Type u_2
𝓕 : Type ?u.130968
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → β → α
u : α → γ
hu : UniformInducing u
this : UniformInducing (↑UniformFun.ofFun ∘ (fun x => u ∘ x) ∘ ↑toFun)
⊢ UniformContinuous ((↑UniformFun.ofFun ∘ (fun x => u ∘ x) ∘ ↑toFun) ∘ ↑UniformFun.ofFun ∘ Function.swap F) ↔
    UniformContinuous (↑UniformFun.ofFun ∘ Function.swap ((fun x x_1 => x ∘ x_1) u ∘ F))
Theorem: PGame.lf_or_equiv_or_gf
File: Mathlib/SetTheory/Game/PGame.lean

tactic: by_cases h : x ⧏ y
state_before: x y : PGame
⊢ x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x

tactic: exact Or.inl h
state_before: case pos
x y : PGame
h : x ⧏ y
⊢ x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x

tactic: right
state_before: case neg
x y : PGame
h : ¬x ⧏ y
⊢ x ⧏ y ∨ (x ≈ y) ∨ y ⧏ x

tactic: cases' lt_or_equiv_of_le (PGame.not_lf.1 h) with h' h'
state_before: case neg.h
x y : PGame
h : ¬x ⧏ y
⊢ (x ≈ y) ∨ y ⧏ x

tactic: exact Or.inr h'.lf
state_before: case neg.h.inl
x y : PGame
h : ¬x ⧏ y
h' : y < x
⊢ (x ≈ y) ∨ y ⧏ x

tactic: exact Or.inl h'.symm
state_before: case neg.h.inr
x y : PGame
h : ¬x ⧏ y
h' : y ≈ x
⊢ (x ≈ y) ∨ y ⧏ x
Theorem: quadratic_eq_zero_iff_of_discrim_eq_zero
File: Mathlib/Algebra/QuadraticDiscriminant.lean

tactic: have : discrim a b c = 0 * 0 := by rw [h, MulZeroClass.mul_zero]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
h : discrim a b c = 0
x : K
⊢ a * x * x + b * x + c = 0 ↔ x = -b / (2 * a)

tactic: rw [quadratic_eq_zero_iff ha this, add_zero, sub_zero, or_self_iff]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
h : discrim a b c = 0
x : K
this : discrim a b c = 0 * 0
⊢ a * x * x + b * x + c = 0 ↔ x = -b / (2 * a)

tactic: rw [h, MulZeroClass.mul_zero]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
h : discrim a b c = 0
x : K
⊢ discrim a b c = 0 * 0
Theorem: Primrec.vector_tail
File: Mathlib/Computability/Primrec.lean

tactic: cases l <;> rfl
state_before: α : Type u_1
β : Type ?u.363665
γ : Type ?u.363668
σ : Type ?u.363671
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
x✝ : Vector α n
l : List α
h : List.length l = n
⊢ List.tail (Vector.toList { val := l, property := h }) = Vector.toList (Vector.tail { val := l, property := h })
Theorem: IsAntichain.image
File: Mathlib/Order/Antichain.lean

tactic: rintro _ ⟨b, hb, rfl⟩ _ ⟨c, hc, rfl⟩ hbc hr
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b : α
hs : IsAntichain r s
f : α → β
h : ∀ ⦃a b : α⦄, r' (f a) (f b) → r a b
⊢ IsAntichain r' (f '' s)

tactic: exact hs hb hc (ne_of_apply_ne _ hbc) (h hr)
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b✝ : α
hs : IsAntichain r s
f : α → β
h : ∀ ⦃a b : α⦄, r' (f a) (f b) → r a b
b : α
hb : b ∈ s
c : α
hc : c ∈ s
hbc : f b ≠ f c
hr : r' (f b) (f c)
⊢ False
Theorem: inner_im_symm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, conj_im]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1286514
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑im (inner x y) = -↑im (inner y x)
Theorem: Ideal.iInf_pow_eq_bot_of_localRing
File: Mathlib/RingTheory/Filtration.lean

tactic: convert I.iInf_pow_smul_eq_bot_of_localRing (M := R) h
state_before: R M : Type u
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
I : Ideal R
F F' : Filtration I M
inst✝¹ : IsNoetherianRing R
inst✝ : LocalRing R
h : I ≠ ⊤
⊢ (⨅ (i : ℕ), I ^ i) = ⊥

tactic: ext i
state_before: case h.e'_2.h.e'_4.h
R M : Type u
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
I : Ideal R
F F' : Filtration I M
inst✝¹ : IsNoetherianRing R
inst✝ : LocalRing R
h : I ≠ ⊤
x✝ : ℕ
⊢ I ^ x✝ = I ^ x✝ • ⊤

tactic: rw [smul_eq_mul, ← Ideal.one_eq_top, mul_one]
state_before: case h.e'_2.h.e'_4.h.h
R M : Type u
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
I : Ideal R
F F' : Filtration I M
inst✝¹ : IsNoetherianRing R
inst✝ : LocalRing R
h : I ≠ ⊤
x✝ : ℕ
i : R
⊢ i ∈ I ^ x✝ ↔ i ∈ I ^ x✝ • ⊤
Theorem: Set.equitableOn_iff_exists_eq_eq_add_one
File: Mathlib/Data/Set/Equitable.lean

tactic: simp_rw [equitableOn_iff_exists_le_le_add_one, Nat.le_and_le_add_one_iff]
state_before: α : Type u_1
β : Type ?u.5357
s : Set α
f : α → ℕ
⊢ EquitableOn s f ↔ ∃ b, ∀ (a : α), a ∈ s → f a = b ∨ f a = b + 1
Theorem: Real.sSup_smul_of_nonneg
File: Mathlib/Data/Real/Pointwise.lean

tactic: obtain rfl | hs := s.eq_empty_or_nonempty
state_before: ι : Sort ?u.3544
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
⊢ sSup (a • s) = a • sSup s

tactic: obtain rfl | ha' := ha.eq_or_lt
state_before: case inr
ι : Sort ?u.3544
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : Set.Nonempty s
⊢ sSup (a • s) = a • sSup s

tactic: by_cases h : BddAbove s
state_before: case inr.inr
ι : Sort ?u.3544
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : Set.Nonempty s
ha' : 0 < a
⊢ sSup (a • s) = a • sSup s

tactic: rw [smul_set_empty, Real.sSup_empty, smul_zero]
state_before: case inl
ι : Sort ?u.3544
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
⊢ sSup (a • ∅) = a • sSup ∅

tactic: rw [zero_smul_set hs, zero_smul]
state_before: case inr.inl
ι : Sort ?u.3544
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
s : Set ℝ
hs : Set.Nonempty s
ha : 0 ≤ 0
⊢ sSup (0 • s) = 0 • sSup s

tactic: exact csSup_singleton 0
state_before: case inr.inl
ι : Sort ?u.3544
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
s : Set ℝ
hs : Set.Nonempty s
ha : 0 ≤ 0
⊢ sSup 0 = 0

tactic: exact ((OrderIso.smulLeft ℝ ha').map_csSup' hs h).symm
state_before: case pos
ι : Sort ?u.3544
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : Set.Nonempty s
ha' : 0 < a
h : BddAbove s
⊢ sSup (a • s) = a • sSup s

tactic: rw [Real.sSup_of_not_bddAbove (mt (bddAbove_smul_iff_of_pos ha').1 h),
    Real.sSup_of_not_bddAbove h, smul_zero]
state_before: case neg
ι : Sort ?u.3544
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : Set.Nonempty s
ha' : 0 < a
h : ¬BddAbove s
⊢ sSup (a • s) = a • sSup s
Theorem: interior_iInter
File: Mathlib/Topology/Basic.lean

tactic: cases nonempty_fintype ι
state_before: α : Type u
β : Type v
ι✝ : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝¹ : TopologicalSpace α
ι : Type u_1
inst✝ : Finite ι
f : ι → Set α
⊢ interior (⋂ (i : ι), f i) = ⋂ (i : ι), interior (f i)

tactic: convert Finset.univ.interior_iInter f <;> simp
state_before: case intro
α : Type u
β : Type v
ι✝ : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝¹ : TopologicalSpace α
ι : Type u_1
inst✝ : Finite ι
f : ι → Set α
val✝ : Fintype ι
⊢ interior (⋂ (i : ι), f i) = ⋂ (i : ι), interior (f i)
Theorem: symmDiff_sdiff_left
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_def, sup_sdiff, sdiff_idem, sdiff_sdiff_self, bot_sup_eq]
state_before: ι : Type ?u.61968
α : Type u_1
β : Type ?u.61974
π : ι → Type ?u.61979
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ∆ b \ a = b \ a
Theorem: CategoryTheory.MonoidalOfChosenFiniteProducts.braiding_naturality
File: Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Symmetric.lean

tactic: dsimp [tensorHom, Limits.BinaryFan.braiding]
state_before: C : Type u
inst✝ : Category C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X X' Y Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ tensorHom ℬ f g ≫ (BinaryFan.braiding (ℬ Y Y').isLimit (ℬ Y' Y).isLimit).hom =
    (BinaryFan.braiding (ℬ X X').isLimit (ℬ X' X).isLimit).hom ≫ tensorHom ℬ g f

tactic: apply (ℬ _ _).isLimit.hom_ext
state_before: C : Type u
inst✝ : Category C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X X' Y Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ IsLimit.lift (ℬ Y Y').isLimit (BinaryFan.mk (BinaryFan.fst (ℬ X X').cone ≫ f) (BinaryFan.snd (ℬ X X').cone ≫ g)) ≫
      (IsLimit.conePointUniqueUpToIso (ℬ Y Y').isLimit (IsLimit.swapBinaryFan (ℬ Y' Y).isLimit)).hom =
    (IsLimit.conePointUniqueUpToIso (ℬ X X').isLimit (IsLimit.swapBinaryFan (ℬ X' X).isLimit)).hom ≫
      IsLimit.lift (ℬ Y' Y).isLimit (BinaryFan.mk (BinaryFan.fst (ℬ X' X).cone ≫ g) (BinaryFan.snd (ℬ X' X).cone ≫ f))

tactic: dsimp [Limits.IsLimit.conePointUniqueUpToIso]
state_before: case mk.right
C : Type u
inst✝ : Category C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X X' Y Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ (IsLimit.lift (ℬ Y Y').isLimit (BinaryFan.mk (BinaryFan.fst (ℬ X X').cone ≫ f) (BinaryFan.snd (ℬ X X').cone ≫ g)) ≫
        (IsLimit.conePointUniqueUpToIso (ℬ Y Y').isLimit (IsLimit.swapBinaryFan (ℬ Y' Y).isLimit)).hom) ≫
      (ℬ Y' Y).cone.π.app { as := WalkingPair.right } =
    ((IsLimit.conePointUniqueUpToIso (ℬ X X').isLimit (IsLimit.swapBinaryFan (ℬ X' X).isLimit)).hom ≫
        IsLimit.lift (ℬ Y' Y).isLimit
          (BinaryFan.mk (BinaryFan.fst (ℬ X' X).cone ≫ g) (BinaryFan.snd (ℬ X' X).cone ≫ f))) ≫
      (ℬ Y' Y).cone.π.app { as := WalkingPair.right }

tactic: simp
state_before: case mk.right
C : Type u
inst✝ : Category C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X X' Y Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ (IsLimit.lift (ℬ Y Y').isLimit (BinaryFan.mk (BinaryFan.fst (ℬ X X').cone ≫ f) (BinaryFan.snd (ℬ X X').cone ≫ g)) ≫
        IsLimit.lift (ℬ Y' Y).isLimit (BinaryFan.swap (ℬ Y Y').cone)) ≫
      BinaryFan.snd (ℬ Y' Y).cone =
    (IsLimit.lift (ℬ X' X).isLimit (BinaryFan.swap (ℬ X X').cone) ≫
        IsLimit.lift (ℬ Y' Y).isLimit
          (BinaryFan.mk (BinaryFan.fst (ℬ X' X).cone ≫ g) (BinaryFan.snd (ℬ X' X).cone ≫ f))) ≫
      BinaryFan.snd (ℬ Y' Y).cone
Theorem: List.length_dropLast_cons
File: src/lean/Init/Data/List/Basic.lean

tactic: match as with
| []       => rfl
| b::bs =>
  have ih := length_dropLast_cons b bs
  simp[dropLast, ih]
state_before: α : Type u
β : Type v
γ : Type w
a : α
as : List α
⊢ length (dropLast (a :: as)) = length as

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
a : α
as : List α
⊢ length (dropLast (a :: nil)) = length nil

tactic: have ih := length_dropLast_cons b bs
state_before: α : Type u
β : Type v
γ : Type w
a : α
as : List α
b : α
bs : List α
⊢ length (dropLast (a :: b :: bs)) = length (b :: bs)

tactic: simp[dropLast, ih]
state_before: α : Type u
β : Type v
γ : Type w
a : α
as : List α
b : α
bs : List α
ih : length (dropLast (b :: bs)) = length bs
⊢ length (dropLast (a :: b :: bs)) = length (b :: bs)
Theorem: Finset.sum_card_bipartiteAbove_eq_sum_card_bipartiteBelow
File: Mathlib/Combinatorics/DoubleCounting.lean

tactic: simp_rw [card_eq_sum_ones, bipartiteAbove, bipartiteBelow, sum_filter]
state_before: α : Type u_1
β : Type u_2
r : α → β → Prop
s : Finset α
t : Finset β
a a' : α
b b' : β
inst✝² : DecidablePred (r a)
inst✝¹ : (a : α) → Decidable (r a b)
m n : ℕ
inst✝ : (a : α) → (b : β) → Decidable (r a b)
⊢ ∑ a in s, card (bipartiteAbove r t a) = ∑ b in t, card (bipartiteBelow r s b)

tactic: exact sum_comm
state_before: α : Type u_1
β : Type u_2
r : α → β → Prop
s : Finset α
t : Finset β
a a' : α
b b' : β
inst✝² : DecidablePred (r a)
inst✝¹ : (a : α) → Decidable (r a b)
m n : ℕ
inst✝ : (a : α) → (b : β) → Decidable (r a b)
⊢ (∑ x in s, ∑ a in t, if r x a then 1 else 0) = ∑ x in t, ∑ a in s, if r a x then 1 else 0
Theorem: Complex.integral_circleTransform
File: Mathlib/MeasureTheory/Integral/CircleTransform.lean

tactic: simp_rw [circleTransform, circleIntegral, deriv_circleMap, circleMap]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
R : ℝ
z w : ℂ
inst✝ : CompleteSpace E
f : ℂ → E
⊢ (∫ (θ : ℝ) in 0 ..2 * π, circleTransform R z w f θ) = (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(z, R), (z - w)⁻¹ • f z

tactic: simp
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
R : ℝ
z w : ℂ
inst✝ : CompleteSpace E
f : ℂ → E
⊢ (∫ (θ : ℝ) in 0 ..2 * π,
      (2 * ↑π * I)⁻¹ • ((0 + ↑R * exp (↑θ * I)) * I) • (z + ↑R * exp (↑θ * I) - w)⁻¹ • f (z + ↑R * exp (↑θ * I))) =
    (2 * ↑π * I)⁻¹ •
      ∫ (θ : ℝ) in 0 ..2 * π, ((0 + ↑R * exp (↑θ * I)) * I) • (z + ↑R * exp (↑θ * I) - w)⁻¹ • f (z + ↑R * exp (↑θ * I))
Theorem: MvPolynomial.map_rename
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: apply MvPolynomial.induction_on p
  (fun a => by simp only [map_C, rename_C])
  (fun p q hp hq => by simp only [hp, hq, AlgHom.map_add, RingHom.map_add]) fun p n hp => by
  simp only [hp, rename_X, map_X, RingHom.map_mul, AlgHom.map_mul]
state_before: σ : Type u_3
τ : Type u_4
α : Type ?u.73427
R : Type u_1
S : Type u_2
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
g : σ → τ
p : MvPolynomial σ R
⊢ ↑(map f) (↑(rename g) p) = ↑(rename g) (↑(map f) p)

tactic: simp only [map_C, rename_C]
state_before: σ : Type u_3
τ : Type u_4
α : Type ?u.73427
R : Type u_1
S : Type u_2
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
g : σ → τ
p : MvPolynomial σ R
a : R
⊢ ↑(map f) (↑(rename g) (↑C a)) = ↑(rename g) (↑(map f) (↑C a))

tactic: simp only [hp, hq, AlgHom.map_add, RingHom.map_add]
state_before: σ : Type u_3
τ : Type u_4
α : Type ?u.73427
R : Type u_1
S : Type u_2
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
g : σ → τ
p✝ p q : MvPolynomial σ R
hp : ↑(map f) (↑(rename g) p) = ↑(rename g) (↑(map f) p)
hq : ↑(map f) (↑(rename g) q) = ↑(rename g) (↑(map f) q)
⊢ ↑(map f) (↑(rename g) (p + q)) = ↑(rename g) (↑(map f) (p + q))

tactic: simp only [hp, rename_X, map_X, RingHom.map_mul, AlgHom.map_mul]
state_before: σ : Type u_3
τ : Type u_4
α : Type ?u.73427
R : Type u_1
S : Type u_2
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
g : σ → τ
p✝ p : MvPolynomial σ R
n : σ
hp : ↑(map f) (↑(rename g) p) = ↑(rename g) (↑(map f) p)
⊢ ↑(map f) (↑(rename g) (p * X n)) = ↑(rename g) (↑(map f) (p * X n))
Theorem: SimpleGraph.Walk.length_eq_zero_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: cases p <;> simp
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
p : Walk G u u
⊢ length p = 0 ↔ p = nil
Theorem: UniformSpace.eq_of_separated_of_uniformContinuous
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: infer_instance
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
x y : α
H : UniformContinuous f
h : x ≈ y
⊢ SeparatedSpace β
Theorem: CategoryTheory.MorphismProperty.RespectsIso.inverseImage
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: constructor
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
P : MorphismProperty D
h : RespectsIso P
F : C ⥤ D
⊢ RespectsIso (MorphismProperty.inverseImage P F)

tactic: all_goals
  intro X Y Z e f hf
  dsimp [MorphismProperty.inverseImage]
  rw [F.map_comp]
state_before: case left
C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
P : MorphismProperty D
h : RespectsIso P
F : C ⥤ D
⊢ ∀ {X Y Z : C} (e : X ≅ Y) (f : Y ⟶ Z),
    MorphismProperty.inverseImage P F f → MorphismProperty.inverseImage P F (e.hom ≫ f)

case right
C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
P : MorphismProperty D
h : RespectsIso P
F : C ⥤ D
⊢ ∀ {X Y Z : C} (e : Y ≅ Z) (f : X ⟶ Y),
    MorphismProperty.inverseImage P F f → MorphismProperty.inverseImage P F (f ≫ e.hom)

tactic: exacts [h.1 (F.mapIso e) (F.map f) hf, h.2 (F.mapIso e) (F.map f) hf]
state_before: case left
C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
P : MorphismProperty D
h : RespectsIso P
F : C ⥤ D
X Y Z : C
e : X ≅ Y
f : Y ⟶ Z
hf : MorphismProperty.inverseImage P F f
⊢ P (F.map e.hom ≫ F.map f)

case right
C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
P : MorphismProperty D
h : RespectsIso P
F : C ⥤ D
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
hf : MorphismProperty.inverseImage P F f
⊢ P (F.map f ≫ F.map e.hom)

tactic: intro X Y Z e f hf
state_before: case right
C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
P : MorphismProperty D
h : RespectsIso P
F : C ⥤ D
⊢ ∀ {X Y Z : C} (e : Y ≅ Z) (f : X ⟶ Y),
    MorphismProperty.inverseImage P F f → MorphismProperty.inverseImage P F (f ≫ e.hom)

tactic: dsimp [MorphismProperty.inverseImage]
state_before: case right
C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
P : MorphismProperty D
h : RespectsIso P
F : C ⥤ D
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
hf : MorphismProperty.inverseImage P F f
⊢ MorphismProperty.inverseImage P F (f ≫ e.hom)

tactic: rw [F.map_comp]
state_before: case right
C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
P : MorphismProperty D
h : RespectsIso P
F : C ⥤ D
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
hf : MorphismProperty.inverseImage P F f
⊢ P (F.map (f ≫ e.hom))