1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.kernelSubobjectIsoComp_hom_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [kernelSubobjectIsoComp]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
X Y Z : C
inst✝³ : HasZeroMorphisms C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
X' : C
f : X' ⟶ X
inst✝¹ : IsIso f
g : X ⟶ Y
inst✝ : HasKernel g
⊢ (kernelSubobjectIsoComp f g).hom ≫ (kernelSubobject g).arrow = (kernelSubobject (f ≫ g)).arrow ≫ f
state_after: no goals
Theorem: Language.map_id
File: Mathlib/Computability/Language.lean

tactic: simp [map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
l : Language α
⊢ (map id) l = l
state_after: no goals
Theorem: Real.Angle.two_zsmul_eq_pi_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [two_zsmul, ← two_nsmul, two_nsmul_eq_pi_iff]
state_before: θ : Angle
⊢ 2 • θ = ↑π ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
state_after: no goals
Theorem: CategoryTheory.Bicategory.leftZigzagIso_inv
File: Mathlib/CategoryTheory/Bicategory/Adjunction.lean

tactic: simp [bicategoricalComp, bicategoricalIsoComp]
state_before: B : Type u
inst✝ : Bicategory B
a b c : B
f : a ⟶ b
g : b ⟶ a
η : 𝟙 a ≅ f ≫ g
ε : g ≫ f ≅ 𝟙 b
⊢ (leftZigzagIso η ε).inv = rightZigzag ε.inv η.inv
state_after: no goals
Theorem: ball_eq_of_symmetry
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: ext y
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V : Set (β × β)
hV : SymmetricRel V
x : β
⊢ ball x V = {y | (y, x) ∈ V}
state_after: case h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V : Set (β × β)
hV : SymmetricRel V
x y : β
⊢ y ∈ ball x V ↔ y ∈ {y | (y, x) ∈ V}

tactic: rw [mem_ball_symmetry hV]
state_before: case h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V : Set (β × β)
hV : SymmetricRel V
x y : β
⊢ y ∈ ball x V ↔ y ∈ {y | (y, x) ∈ V}
state_after: case h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V : Set (β × β)
hV : SymmetricRel V
x y : β
⊢ x ∈ ball y V ↔ y ∈ {y | (y, x) ∈ V}

tactic: exact Iff.rfl
state_before: case h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V : Set (β × β)
hV : SymmetricRel V
x y : β
⊢ x ∈ ball y V ↔ y ∈ {y | (y, x) ∈ V}
state_after: no goals
Theorem: Ideal.eq_top_iff_one
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rintro rfl
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
⊢ I = ⊤ → 1 ∈ I
state_after: α : Type u
β : Type v
inst✝ : Semiring α
a b : α
⊢ 1 ∈ ⊤

tactic: trivial
state_before: α : Type u
β : Type v
inst✝ : Semiring α
a b : α
⊢ 1 ∈ ⊤
state_after: no goals

tactic: simp
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
h : 1 ∈ I
⊢ 1 * 1 = 1
state_after: no goals
Theorem: Sylow.exists_subgroup_card_pow_prime
File: Mathlib/GroupTheory/Sylow.lean

tactic: rw [← @Nat.card_eq_fintype_card, card_bot, pow_zero]
state_before: G : Type u
α : Type v
β : Type w
inst✝² : Group G
inst✝¹ : Fintype G
p n : ℕ
inst✝ : Fact (Nat.Prime p)
hdvd : p ^ n ∣ Fintype.card G
⊢ Fintype.card ↥⊥ = p ^ 0
state_after: no goals
Theorem: Int.emod_two_ne_zero
File: Mathlib/Algebra/Group/Int.lean

tactic: cases' emod_two_eq_zero_or_one n with h h <;> simp [h]
state_before: u v m n : ℤ
⊢ ¬n % 2 = 0 ↔ n % 2 = 1
state_after: no goals
Theorem: inner_mul_symm_re_eq_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, mul_comm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ re (⟪x, y⟫_𝕜 * ⟪y, x⟫_𝕜) = ‖⟪x, y⟫_𝕜 * ⟪y, x⟫_𝕜‖
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ re (⟪y, x⟫_𝕜 * (starRingEnd 𝕜) ⟪y, x⟫_𝕜) = ‖⟪y, x⟫_𝕜 * (starRingEnd 𝕜) ⟪y, x⟫_𝕜‖

tactic: exact re_eq_norm_of_mul_conj (inner y x)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ re (⟪y, x⟫_𝕜 * (starRingEnd 𝕜) ⟪y, x⟫_𝕜) = ‖⟪y, x⟫_𝕜 * (starRingEnd 𝕜) ⟪y, x⟫_𝕜‖
state_after: no goals
Theorem: CategoryTheory.wellPowered_of_isDetecting
File: Mathlib/CategoryTheory/Generator.lean

tactic: simpa [Set.ext_iff] using h
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasPullbacks C
𝒢 : Set C
inst✝ : Small.{v₁, u₁} ↑𝒢
h𝒢 : IsDetecting 𝒢
X : C
P Q : Subobject X
h : (fun P => {f | P.Factors f.snd}) P = (fun P => {f | P.Factors f.snd}) Q
⊢ ∀ G ∈ 𝒢, ∀ {f : G ⟶ X}, P.Factors f ↔ Q.Factors f
state_after: no goals
Theorem: Vector.toList_append
File: Mathlib/Data/Vector/Defs.lean

tactic: cases v
state_before: α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
v : Vector α n
w : Vector α m
⊢ (v.append w).toList = v.toList ++ w.toList
state_after: case mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
w : Vector α m
val✝ : List α
property✝ : val✝.length = n
⊢ (append ⟨val✝, property✝⟩ w).toList = toList ⟨val✝, property✝⟩ ++ w.toList

tactic: cases w
state_before: case mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
w : Vector α m
val✝ : List α
property✝ : val✝.length = n
⊢ (append ⟨val✝, property✝⟩ w).toList = toList ⟨val✝, property✝⟩ ++ w.toList
state_after: case mk.mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
val✝¹ : List α
property✝¹ : val✝¹.length = n
val✝ : List α
property✝ : val✝.length = m
⊢ (append ⟨val✝¹, property✝¹⟩ ⟨val✝, property✝⟩).toList = toList ⟨val✝¹, property✝¹⟩ ++ toList ⟨val✝, property✝⟩

tactic: rfl
state_before: case mk.mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
val✝¹ : List α
property✝¹ : val✝¹.length = n
val✝ : List α
property✝ : val✝.length = m
⊢ (append ⟨val✝¹, property✝¹⟩ ⟨val✝, property✝⟩).toList = toList ⟨val✝¹, property✝¹⟩ ++ toList ⟨val✝, property✝⟩
state_after: no goals
Theorem: OmegaCompletePartialOrder.ωSup_total
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: simp only [not_forall] at this ⊢
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
x : α
h : ∀ (i : ℕ), c i ≤ x ∨ x ≤ c i
this : ¬∀ (i : ℕ), c i ≤ x
⊢ ∃ i, ¬c i ≤ x
state_after: α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
x : α
h : ∀ (i : ℕ), c i ≤ x ∨ x ≤ c i
this : ∃ x_1, ¬c x_1 ≤ x
⊢ ∃ i, ¬c i ≤ x

tactic: assumption
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
x : α
h : ∀ (i : ℕ), c i ≤ x ∨ x ≤ c i
this : ∃ x_1, ¬c x_1 ≤ x
⊢ ∃ i, ¬c i ≤ x
state_after: no goals
Theorem: IsGroupHom.preimage_normal
File: Mathlib/Deprecated/Subgroup.lean

tactic: simp [hf.map_one, hs.toIsSubgroup.one_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ 1 ∈ f ⁻¹' s
state_after: no goals

tactic: simp (config := { contextual := true }) [hf.map_mul, hs.toIsSubgroup.mul_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ ∀ {a b : G}, a ∈ f ⁻¹' s → b ∈ f ⁻¹' s → a * b ∈ f ⁻¹' s
state_after: no goals

tactic: simp (config := { contextual := true }) [hf.map_inv, hs.toIsSubgroup.inv_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ ∀ {a : G}, a ∈ f ⁻¹' s → a⁻¹ ∈ f ⁻¹' s
state_after: no goals

tactic: simp (config := { contextual := true }) [hs.normal, hf.map_mul, hf.map_inv]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ ∀ n ∈ f ⁻¹' s, ∀ (g : G), g * n * g⁻¹ ∈ f ⁻¹' s
state_after: no goals
Theorem: MvPFunctor.M.map_dest
File: Mathlib/Data/PFunctor/Multivariate/M.lean

tactic: rw [M.dest_map]
state_before: n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ g <$$> dest P x = dest P (dropFun g <$$> x)
state_after: n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ g <$$> dest P x = (dropFun g ::: fun x => dropFun g <$$> x) <$$> dest P x

tactic: congr
state_before: n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ g <$$> dest P x = (dropFun g ::: fun x => dropFun g <$$> x) <$$> dest P x
state_after: case e_a
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ g = (dropFun g ::: fun x => dropFun g <$$> x)

tactic: apply eq_of_drop_last_eq <;> simp
state_before: case e_a
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ g = (dropFun g ::: fun x => dropFun g <$$> x)
state_after: case e_a.h₁
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ lastFun g = fun x => dropFun g <$$> x

tactic: ext1
state_before: case e_a.h₁
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ lastFun g = fun x => dropFun g <$$> x
state_after: case e_a.h₁.h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
x✝ : (α ::: P.M α).last
⊢ lastFun g x✝ = dropFun g <$$> x✝

tactic: apply h
state_before: case e_a.h₁.h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
x✝ : (α ::: P.M α).last
⊢ lastFun g x✝ = dropFun g <$$> x✝
state_after: no goals
Theorem: OnePoint.isOpen_iff_of_mem'
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: simp [isOpen_def, h]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
h : ∞ ∈ s
⊢ IsOpen s ↔ IsCompact (some ⁻¹' s)ᶜ ∧ IsOpen (some ⁻¹' s)
state_after: no goals
Theorem: List.rel_perm_imp
File: Mathlib/Data/List/Perm.lean

tactic: rwa [← forall₂_comp_perm_eq_perm_comp_forall₂, ← Relation.comp_assoc] at this
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
hr : RightUnique r
a : List α
b : List β
h₁ : Forall₂ r a b
c : List α
d : List β
h₂ : Forall₂ r c d
h : a ~ c
this : (flip (Forall₂ r) ∘r Perm ∘r Forall₂ r) b d
⊢ ((flip (Forall₂ r) ∘r Forall₂ r) ∘r Perm) b d
state_after: no goals
Theorem: Complex.exp_eq_exp_iff_exists_int
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp only [exp_eq_exp_iff_exp_sub_eq_one, exp_eq_one_iff, sub_eq_iff_eq_add']
state_before: x y : ℂ
⊢ cexp x = cexp y ↔ ∃ n, x = y + ↑n * (2 * ↑π * I)
state_after: no goals
Theorem: aemeasurable_of_map_neZero
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

tactic: by_contra h'
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f✝ g : α → β
μ✝ ν : Measure α
mβ : MeasurableSpace β
μ : Measure α
f : α → β
h : NeZero (Measure.map f μ)
⊢ AEMeasurable f μ
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f✝ g : α → β
μ✝ ν : Measure α
mβ : MeasurableSpace β
μ : Measure α
f : α → β
h : NeZero (Measure.map f μ)
h' : ¬AEMeasurable f μ
⊢ False

tactic: simp [h'] at h
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f✝ g : α → β
μ✝ ν : Measure α
mβ : MeasurableSpace β
μ : Measure α
f : α → β
h : NeZero (Measure.map f μ)
h' : ¬AEMeasurable f μ
⊢ False
state_after: no goals
Theorem: Turing.TM2to1.addBottom_nth_succ_fst
File: Mathlib/Computability/TuringMachine.lean

tactic: rw [ListBlank.nth_succ, addBottom, ListBlank.tail_cons, ListBlank.nth_map]
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
L : ListBlank ((k : K) → Option (Γ k))
n : ℕ
⊢ ((addBottom L).nth (n + 1)).1 = false
state_after: no goals
Theorem: Pell.xy_modEq_of_modEq
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: constructor <;> rfl
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
⊢ xn a1 0 ≡ xn b1 0 [MOD c] ∧ yn a1 0 ≡ yn b1 0 [MOD c]
state_after: no goals

tactic: simp
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
⊢ xn a1 1 ≡ xn b1 1 [MOD c] ∧ yn a1 1 ≡ yn b1 1 [MOD c]
state_after: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
⊢ a ≡ b [MOD c] ∧ 1 ≡ 1 [MOD c]

tactic: exact ⟨h, ModEq.refl 1⟩
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
⊢ a ≡ b [MOD c] ∧ 1 ≡ 1 [MOD c]
state_after: no goals

tactic: rw [xn_succ_succ a1, xn_succ_succ b1]
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
n : ℕ
⊢ xn a1 (n + 2) + xn a1 n ≡ xn b1 (n + 2) + xn b1 n [MOD c]
state_after: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
n : ℕ
⊢ 2 * a * xn a1 (n + 1) ≡ 2 * b * xn b1 (n + 1) [MOD c]

tactic: exact (h.mul_left _).mul (xy_modEq_of_modEq _ _ h (n + 1)).left
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
n : ℕ
⊢ 2 * a * xn a1 (n + 1) ≡ 2 * b * xn b1 (n + 1) [MOD c]
state_after: no goals

tactic: rw [yn_succ_succ a1, yn_succ_succ b1]
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
n : ℕ
⊢ yn a1 (n + 2) + yn ⋯ n ≡ yn b1 (n + 2) + yn ⋯ n [MOD c]
state_after: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
n : ℕ
⊢ 2 * a * yn a1 (n + 1) ≡ 2 * b * yn b1 (n + 1) [MOD c]

tactic: exact (h.mul_left _).mul (xy_modEq_of_modEq _ _ h (n + 1)).right
state_before: a b c : ℕ
a1 : 1 < a
b1 : 1 < b
h : a ≡ b [MOD c]
n : ℕ
⊢ 2 * a * yn a1 (n + 1) ≡ 2 * b * yn b1 (n + 1) [MOD c]
state_after: no goals
Theorem: String.Iterator.ValidFor.out'
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [List.reverseAux_eq]
state_before: l r : List Char
⊢ { s := { data := l.reverseAux r }, i := { byteIdx := utf8Len l } } =
    { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
state_after: no goals
Theorem: nhdsWithin_pi_eq
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [nhdsWithin, nhds_pi, Filter.pi, pi_def, ← iInf_principal_finite hI, comap_inf,
  comap_principal, eval]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
I : Set ι
hI : I.Finite
s : (i : ι) → Set (π i)
x : (i : ι) → π i
⊢ 𝓝[I.pi s] x = (⨅ i ∈ I, comap (fun x => x i) (𝓝[s i] x i)) ⊓ ⨅ i, ⨅ (_ : i ∉ I), comap (fun x => x i) (𝓝 (x i))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
I : Set ι
hI : I.Finite
s : (i : ι) → Set (π i)
x : (i : ι) → π i
⊢ (⨅ i, comap (eval i) (𝓝 (x i))) ⊓ ⨅ i ∈ I, 𝓟 (eval i ⁻¹' s i) =
    (⨅ i ∈ I, comap (fun x => x i) (𝓝 (x i)) ⊓ 𝓟 ((fun x => x i) ⁻¹' s i)) ⊓
      ⨅ i, ⨅ (_ : i ∉ I), comap (fun x => x i) (𝓝 (x i))

tactic: rw [iInf_split _ fun i => i ∈ I, inf_right_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
I : Set ι
hI : I.Finite
s : (i : ι) → Set (π i)
x : (i : ι) → π i
⊢ (⨅ i, comap (eval i) (𝓝 (x i))) ⊓ ⨅ i ∈ I, 𝓟 (eval i ⁻¹' s i) =
    (⨅ i ∈ I, comap (fun x => x i) (𝓝 (x i)) ⊓ 𝓟 ((fun x => x i) ⁻¹' s i)) ⊓
      ⨅ i, ⨅ (_ : i ∉ I), comap (fun x => x i) (𝓝 (x i))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
I : Set ι
hI : I.Finite
s : (i : ι) → Set (π i)
x : (i : ι) → π i
⊢ ((⨅ i ∈ I, comap (eval i) (𝓝 (x i))) ⊓ ⨅ i ∈ I, 𝓟 (eval i ⁻¹' s i)) ⊓ ⨅ i, ⨅ (_ : i ∉ I), comap (eval i) (𝓝 (x i)) =
    (⨅ i ∈ I, comap (fun x => x i) (𝓝 (x i)) ⊓ 𝓟 ((fun x => x i) ⁻¹' s i)) ⊓
      ⨅ i, ⨅ (_ : i ∉ I), comap (fun x => x i) (𝓝 (x i))

tactic: simp only [iInf_inf_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
I : Set ι
hI : I.Finite
s : (i : ι) → Set (π i)
x : (i : ι) → π i
⊢ ((⨅ i ∈ I, comap (eval i) (𝓝 (x i))) ⊓ ⨅ i ∈ I, 𝓟 (eval i ⁻¹' s i)) ⊓ ⨅ i, ⨅ (_ : i ∉ I), comap (eval i) (𝓝 (x i)) =
    (⨅ i ∈ I, comap (fun x => x i) (𝓝 (x i)) ⊓ 𝓟 ((fun x => x i) ⁻¹' s i)) ⊓
      ⨅ i, ⨅ (_ : i ∉ I), comap (fun x => x i) (𝓝 (x i))
state_after: no goals
Theorem: cfcₙHom_eq_of_continuous_of_map_id
File: Mathlib/Topology/ContinuousFunction/NonUnitalFunctionalCalculus.lean

tactic: rw [cfcₙHom_id ha, hφ₂]
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹³ : CommSemiring R
inst✝¹² : Nontrivial R
inst✝¹¹ : StarRing R
inst✝¹⁰ : MetricSpace R
inst✝⁹ : TopologicalSemiring R
inst✝⁸ : ContinuousStar R
inst✝⁷ : NonUnitalRing A
inst✝⁶ : StarRing A
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Module R A
inst✝³ : IsScalarTower R A A
inst✝² : SMulCommClass R A A
inst✝¹ : NonUnitalContinuousFunctionalCalculus R p
a : A
ha : p a
inst✝ : UniqueNonUnitalContinuousFunctionalCalculus R A
φ : C(↑(σₙ R a), R)₀ →⋆ₙₐ[R] A
hφ₁ : Continuous ⇑φ
hφ₂ : φ { toContinuousMap := ContinuousMap.restrict (σₙ R a) (ContinuousMap.id R), map_zero' := ⋯ } = a
⊢ (cfcₙHom ha) { toContinuousMap := ContinuousMap.restrict (σₙ R a) (ContinuousMap.id R), map_zero' := ⋯ } =
    φ { toContinuousMap := ContinuousMap.restrict (σₙ R a) (ContinuousMap.id R), map_zero' := ⋯ }
state_after: no goals
Theorem: IsSelfAdjoint.inv
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [isSelfAdjoint_iff, star_inv', hx.star_eq]
state_before: R : Type u_1
A : Type u_2
inst✝¹ : DivisionSemiring R
inst✝ : StarRing R
x : R
hx : IsSelfAdjoint x
⊢ IsSelfAdjoint x⁻¹
state_after: no goals
Theorem: Multiset.noncommProd_eq_pow_card
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: induction s using Quotient.inductionOn
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
s : Multiset α
comm : {x | x ∈ s}.Pairwise Commute
m : α
h : ∀ x ∈ s, x = m
⊢ s.noncommProd comm = m ^ card s
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
m : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ ⟦a✝⟧, x = m
⊢ noncommProd ⟦a✝⟧ comm = m ^ card ⟦a✝⟧

tactic: simp only [quot_mk_to_coe, noncommProd_coe, coe_card, mem_coe] at *
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
m : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ ⟦a✝⟧, x = m
⊢ noncommProd ⟦a✝⟧ comm = m ^ card ⟦a✝⟧
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
m : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ a✝, x = m
⊢ a✝.prod = m ^ a✝.length

tactic: exact List.prod_eq_pow_card _ m h
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
m : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ a✝, x = m
⊢ a✝.prod = m ^ a✝.length
state_after: no goals
Theorem: CategoryTheory.IsPushout.of_horiz_isIso
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: refine
  PushoutCocone.IsColimit.mk _ (fun s => inv inr ≫ s.inr) (fun s => ?_)
    (by aesop_cat) (by aesop_cat)
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : IsIso f
inst✝ : IsIso inr
sq : CommSq f g inl inr
⊢ IsColimit sq.cocone
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : IsIso f
inst✝ : IsIso inr
sq : CommSq f g inl inr
s : PushoutCocone f g
⊢ inl ≫ (fun s => inv inr ≫ s.inr) s = s.inl

tactic: simp only [← cancel_epi f, s.condition, sq.w_assoc, IsIso.hom_inv_id_assoc]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : IsIso f
inst✝ : IsIso inr
sq : CommSq f g inl inr
s : PushoutCocone f g
⊢ inl ≫ (fun s => inv inr ≫ s.inr) s = s.inl
state_after: no goals

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : IsIso f
inst✝ : IsIso inr
sq : CommSq f g inl inr
⊢ ∀ (s : PushoutCocone f g), inr ≫ (fun s => inv inr ≫ s.inr) s = s.inr
state_after: no goals

tactic: aesop_cat
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : IsIso f
inst✝ : IsIso inr
sq : CommSq f g inl inr
⊢ ∀ (s : PushoutCocone f g) (m : P ⟶ s.pt), inl ≫ m = s.inl → inr ≫ m = s.inr → m = (fun s => inv inr ≫ s.inr) s
state_after: no goals
Theorem: Finset.sum_range_id_mul_two
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: rw [sum_range_reflect (fun i => i) n, mul_two]
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f : α → M
n : ℕ
⊢ (∑ i ∈ range n, i) * 2 = ∑ i ∈ range n, i + ∑ i ∈ range n, (n - 1 - i)
state_after: no goals

tactic: rw [sum_const, card_range, Nat.nsmul_eq_mul]
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f : α → M
n : ℕ
⊢ ∑ i ∈ range n, (n - 1) = n * (n - 1)
state_after: no goals
Theorem: Part.sdiff_mem_sdiff
File: Mathlib/Data/Part.lean

tactic: simp [sdiff_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : SDiff α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ma \ mb ∈ a \ b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : SDiff α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ∃ a_1 ∈ a, ∃ a ∈ b, a_1 \ a = ma \ mb

tactic: aesop
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : SDiff α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ∃ a_1 ∈ a, ∃ a ∈ b, a_1 \ a = ma \ mb
state_after: no goals
Theorem: SimplexCategory.image_ι_eq
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: haveI := strongEpi_of_epi e
state_before: Δ Δ'' : SimplexCategory
φ : Δ ⟶ Δ''
e : Δ ⟶ image φ
inst✝¹ : Epi e
i : image φ ⟶ Δ''
inst✝ : Mono i
fac : e ≫ i = φ
⊢ image.ι φ = i
state_after: Δ Δ'' : SimplexCategory
φ : Δ ⟶ Δ''
e : Δ ⟶ image φ
inst✝¹ : Epi e
i : image φ ⟶ Δ''
inst✝ : Mono i
fac : e ≫ i = φ
this : StrongEpi e
⊢ image.ι φ = i

tactic: rw [← image.isoStrongEpiMono_hom_comp_ι e i fac,
  SimplexCategory.eq_id_of_isIso (image.isoStrongEpiMono e i fac).hom, Category.id_comp]
state_before: Δ Δ'' : SimplexCategory
φ : Δ ⟶ Δ''
e : Δ ⟶ image φ
inst✝¹ : Epi e
i : image φ ⟶ Δ''
inst✝ : Mono i
fac : e ≫ i = φ
this : StrongEpi e
⊢ image.ι φ = i
state_after: no goals