tasksource/leandojo huggingface dataset:
Theorem: Preimage.isSubfield
File: Mathlib/Deprecated/Subfield.lean

tactic: rw [map_inv₀]
state_before: F : Type u_2
inst✝¹ : Field F
S : Set F
K : Type u_1
inst✝ : Field K
f : F →+* K
s : Set K
hs : IsSubfield s
src✝ : IsSubring (↑f ⁻¹' s) := RingHom.isSubring_preimage f hs.toIsSubring
a : F
ha : ↑f a ∈ s
⊢ ↑f a⁻¹ ∈ s

tactic: exact hs.inv_mem ha
state_before: F : Type u_2
inst✝¹ : Field F
S : Set F
K : Type u_1
inst✝ : Field K
f : F →+* K
s : Set K
hs : IsSubfield s
src✝ : IsSubring (↑f ⁻¹' s) := RingHom.isSubring_preimage f hs.toIsSubring
a : F
ha : ↑f a ∈ s
⊢ (↑f a)⁻¹ ∈ s
Theorem: normalize_idem
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
x : α
⊢ ↑normalize (↑normalize x) = ↑normalize x
Theorem: Con.zpow
File: Mathlib/GroupTheory/Congruence.lean

tactic: simpa only [zpow_ofNat, Int.ofNat_eq_coe] using c.pow n h
state_before: M : Type u_1
N : Type ?u.99934
P : Type ?u.99937
inst✝² : Group M
inst✝¹ : Group N
inst✝ : Group P
c : Con M
n : ℕ
w x : M
h : ↑c w x
⊢ ↑c (w ^ Int.ofNat n) (x ^ Int.ofNat n)

tactic: simpa only [zpow_negSucc] using c.inv (c.pow _ h)
state_before: M : Type u_1
N : Type ?u.99934
P : Type ?u.99937
inst✝² : Group M
inst✝¹ : Group N
inst✝ : Group P
c : Con M
n : ℕ
w x : M
h : ↑c w x
⊢ ↑c (w ^ Int.negSucc n) (x ^ Int.negSucc n)
Theorem: EuclideanGeometry.orthogonalProjectionFn_mem
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: rw [← mem_coe, ← Set.singleton_subset_iff, ← inter_eq_singleton_orthogonalProjectionFn]
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : P
⊢ orthogonalProjectionFn s p ∈ s

tactic: exact Set.inter_subset_left _ _
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : P
⊢ ↑s ∩ ↑(mk' p (direction s)ᗮ) ⊆ ↑s
Theorem: Matrix.fromBlocks_submatrix_sum_swap_left
File: Mathlib/Data/Matrix/Block.lean

tactic: ext (i j)
state_before: l : Type u_2
m : Type u_4
n : Type u_1
o : Type u_5
p : Type u_6
q : Type ?u.18703
m' : o → Type ?u.18708
n' : o → Type ?u.18713
p' : o → Type ?u.18718
R : Type ?u.18721
S : Type ?u.18724
α : Type u_3
β : Type ?u.18730
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
f : p → l ⊕ m
⊢ submatrix (fromBlocks A B C D) Sum.swap f = submatrix (fromBlocks C D A B) id f

tactic: cases i <;> dsimp <;> cases f j <;> rfl
state_before: case a.h
l : Type u_2
m : Type u_4
n : Type u_1
o : Type u_5
p : Type u_6
q : Type ?u.18703
m' : o → Type ?u.18708
n' : o → Type ?u.18713
p' : o → Type ?u.18718
R : Type ?u.18721
S : Type ?u.18724
α : Type u_3
β : Type ?u.18730
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
f : p → l ⊕ m
i : o ⊕ n
j : p
⊢ submatrix (fromBlocks A B C D) Sum.swap f i j = submatrix (fromBlocks C D A B) id f i j
Theorem: dist_triangle_left
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [dist_comm z]
state_before: α : Type u
β : Type v
X : Type ?u.9703
ι : Type ?u.9706
inst✝ : PseudoMetricSpace α
x y z : α
⊢ dist x y ≤ dist z x + dist z y

tactic: apply dist_triangle
state_before: α : Type u
β : Type v
X : Type ?u.9703
ι : Type ?u.9706
inst✝ : PseudoMetricSpace α
x y z : α
⊢ dist x y ≤ dist x z + dist z y
Theorem: GradedMonoid.list_prod_map_eq_dProd
File: Mathlib/Algebra/GradedMonoid.lean

tactic: rw [GradedMonoid.mk_list_dProd, GradedMonoid.mk]
state_before: ι : Type u_2
α : Type u_1
A : ι → Type u_3
inst✝¹ : AddMonoid ι
inst✝ : GMonoid A
l : List α
f : α → GradedMonoid A
⊢ List.prod (List.map f l) =
    mk (List.dProdIndex l fun i => (f i).fst) (List.dProd l (fun i => (f i).fst) fun i => (f i).snd)

tactic: simp_rw [Sigma.eta]
state_before: ι : Type u_2
α : Type u_1
A : ι → Type u_3
inst✝¹ : AddMonoid ι
inst✝ : GMonoid A
l : List α
f : α → GradedMonoid A
⊢ List.prod (List.map f l) = List.prod (List.map (fun a => { fst := (f a).fst, snd := (f a).snd }) l)
Theorem: IsConformalMap.comp
File: Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean

tactic: rcases hf with ⟨cf, hcf, lif, rfl⟩
state_before: R : Type u_1
M : Type u_4
N : Type u_2
G : Type u_3
M' : Type ?u.216873
inst✝⁸ : NormedField R
inst✝⁷ : SeminormedAddCommGroup M
inst✝⁶ : SeminormedAddCommGroup N
inst✝⁵ : SeminormedAddCommGroup G
inst✝⁴ : NormedSpace R M
inst✝³ : NormedSpace R N
inst✝² : NormedSpace R G
inst✝¹ : NormedAddCommGroup M'
inst✝ : NormedSpace R M'
f : M →L[R] N
g : N →L[R] G
c : R
hg : IsConformalMap g
hf : IsConformalMap f
⊢ IsConformalMap (ContinuousLinearMap.comp g f)

tactic: rcases hg with ⟨cg, hcg, lig, rfl⟩
state_before: case intro.intro.intro
R : Type u_1
M : Type u_4
N : Type u_2
G : Type u_3
M' : Type ?u.216873
inst✝⁸ : NormedField R
inst✝⁷ : SeminormedAddCommGroup M
inst✝⁶ : SeminormedAddCommGroup N
inst✝⁵ : SeminormedAddCommGroup G
inst✝⁴ : NormedSpace R M
inst✝³ : NormedSpace R N
inst✝² : NormedSpace R G
inst✝¹ : NormedAddCommGroup M'
inst✝ : NormedSpace R M'
g : N →L[R] G
c : R
hg : IsConformalMap g
cf : R
hcf : cf ≠ 0
lif : M →ₗᵢ[R] N
⊢ IsConformalMap (ContinuousLinearMap.comp g (cf • toContinuousLinearMap lif))

tactic: refine' ⟨cg * cf, mul_ne_zero hcg hcf, lig.comp lif, _⟩
state_before: case intro.intro.intro.intro.intro.intro
R : Type u_1
M : Type u_4
N : Type u_2
G : Type u_3
M' : Type ?u.216873
inst✝⁸ : NormedField R
inst✝⁷ : SeminormedAddCommGroup M
inst✝⁶ : SeminormedAddCommGroup N
inst✝⁵ : SeminormedAddCommGroup G
inst✝⁴ : NormedSpace R M
inst✝³ : NormedSpace R N
inst✝² : NormedSpace R G
inst✝¹ : NormedAddCommGroup M'
inst✝ : NormedSpace R M'
c cf : R
hcf : cf ≠ 0
lif : M →ₗᵢ[R] N
cg : R
hcg : cg ≠ 0
lig : N →ₗᵢ[R] G
⊢ IsConformalMap (ContinuousLinearMap.comp (cg • toContinuousLinearMap lig) (cf • toContinuousLinearMap lif))

tactic: rw [smul_comp, comp_smul, mul_smul]
state_before: case intro.intro.intro.intro.intro.intro
R : Type u_1
M : Type u_4
N : Type u_2
G : Type u_3
M' : Type ?u.216873
inst✝⁸ : NormedField R
inst✝⁷ : SeminormedAddCommGroup M
inst✝⁶ : SeminormedAddCommGroup N
inst✝⁵ : SeminormedAddCommGroup G
inst✝⁴ : NormedSpace R M
inst✝³ : NormedSpace R N
inst✝² : NormedSpace R G
inst✝¹ : NormedAddCommGroup M'
inst✝ : NormedSpace R M'
c cf : R
hcf : cf ≠ 0
lif : M →ₗᵢ[R] N
cg : R
hcg : cg ≠ 0
lig : N →ₗᵢ[R] G
⊢ ContinuousLinearMap.comp (cg • toContinuousLinearMap lig) (cf • toContinuousLinearMap lif) =
    (cg * cf) • toContinuousLinearMap (LinearIsometry.comp lig lif)

tactic: rfl
state_before: case intro.intro.intro.intro.intro.intro
R : Type u_1
M : Type u_4
N : Type u_2
G : Type u_3
M' : Type ?u.216873
inst✝⁸ : NormedField R
inst✝⁷ : SeminormedAddCommGroup M
inst✝⁶ : SeminormedAddCommGroup N
inst✝⁵ : SeminormedAddCommGroup G
inst✝⁴ : NormedSpace R M
inst✝³ : NormedSpace R N
inst✝² : NormedSpace R G
inst✝¹ : NormedAddCommGroup M'
inst✝ : NormedSpace R M'
c cf : R
hcf : cf ≠ 0
lif : M →ₗᵢ[R] N
cg : R
hcg : cg ≠ 0
lig : N →ₗᵢ[R] G
⊢ cg • cf • ContinuousLinearMap.comp (toContinuousLinearMap lig) (toContinuousLinearMap lif) =
    cg • cf • toContinuousLinearMap (LinearIsometry.comp lig lif)
Theorem: LinearEquiv.det_mul_det_symm
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: simp [← LinearMap.det_comp]
state_before: R : Type ?u.1583222
inst✝⁸ : CommRing R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.1583813
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type ?u.1584355
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e : Basis ι R M
A : Type u_1
inst✝¹ : CommRing A
inst✝ : Module A M
f : M ≃ₗ[A] M
⊢ ↑LinearMap.det ↑f * ↑LinearMap.det ↑(symm f) = 1
Theorem: NNReal.mul_self_sqrt
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← sq, sq_sqrt]
state_before: x✝ y x : ℝ≥0
⊢ ↑sqrt x * ↑sqrt x = x
Theorem: Nat.ofDigits_eq_sum_mapIdx
File: Mathlib/Data/Nat/Digits.lean

tactic: rw [List.mapIdx_eq_enum_map, List.enum_eq_zip_range, List.map_uncurry_zip_eq_zipWith,
  ofDigits_eq_foldr]
state_before: n b : ℕ
L : List ℕ
⊢ ofDigits b L = List.sum (List.mapIdx (fun i a => a * b ^ i) L)

tactic: induction' L with hd tl hl
state_before: n b : ℕ
L : List ℕ
⊢ List.foldr (fun x y => ↑x + b * y) 0 L = List.sum (List.zipWith (fun i a => a * b ^ i) (List.range (List.length L)) L)

tactic: simp
state_before: case nil
n b : ℕ
⊢ List.foldr (fun x y => ↑x + b * y) 0 [] =
    List.sum (List.zipWith (fun i a => a * b ^ i) (List.range (List.length [])) [])

tactic: simpa [List.range_succ_eq_map, List.zipWith_map_left, ofDigits_eq_sum_map_with_index_aux] using
  Or.inl hl
state_before: case cons
n b hd : ℕ
tl : List ℕ
hl :
  List.foldr (fun x y => ↑x + b * y) 0 tl =
    List.sum (List.zipWith (fun i a => a * b ^ i) (List.range (List.length tl)) tl)
⊢ List.foldr (fun x y => ↑x + b * y) 0 (hd :: tl) =
    List.sum (List.zipWith (fun i a => a * b ^ i) (List.range (List.length (hd :: tl))) (hd :: tl))
Theorem: CategoryTheory.Limits.PreservesPushout.inl_iso_inv
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean

tactic: simp [PreservesPushout.iso, Iso.comp_inv_eq]
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
G : C ⥤ D
W X Y Z : C
h : X ⟶ Z
k : Y ⟶ Z
f : W ⟶ X
g : W ⟶ Y
comm : f ≫ h = g ≫ k
inst✝² : PreservesColimit (span f g) G
inst✝¹ : HasPushout f g
inst✝ : HasPushout (G.map f) (G.map g)
⊢ G.map pushout.inl ≫ (iso G f g).inv = pushout.inl
Theorem: Filter.isBounded_top
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [IsBounded, eq_univ_iff_forall]
state_before: α : Type u_1
β : Type ?u.3399
γ : Type ?u.3402
ι : Type ?u.3405
r : α → α → Prop
f g : Filter α
⊢ IsBounded r ⊤ ↔ ∃ t, ∀ (x : α), r x t
Theorem: Traversable.traverse_id
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: ext
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x : t β
⊢ traverse pure = pure

tactic: exact id_traverse _
state_before: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x : t β
x✝ : t α
⊢ traverse pure x✝ = pure x✝
Theorem: LieAlgebra.Orthogonal.pso_inv
File: Mathlib/Algebra/Lie/Classical.lean

tactic: ext (x y)
state_before: n : Type ?u.36435
p : Type u_1
q : Type u_2
l : Type ?u.36444
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
⊢ Pso p q R i * Pso p q R (-i) = 1

tactic: rcases x with ⟨x⟩|⟨x⟩ <;> rcases y with ⟨y⟩|⟨y⟩
state_before: case a.h
n : Type ?u.36435
p : Type u_1
q : Type u_2
l : Type ?u.36444
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x y : p ⊕ q
⊢ (Pso p q R i * Pso p q R (-i)) x y = OfNat.ofNat 1 x y

tactic: by_cases h : x = y <;>
simp [Pso, indefiniteDiagonal, h]
state_before: case a.h.inl.inl
n : Type ?u.36435
p : Type u_1
q : Type u_2
l : Type ?u.36444
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x y : p
⊢ (Pso p q R i * Pso p q R (-i)) (Sum.inl x) (Sum.inl y) = OfNat.ofNat 1 (Sum.inl x) (Sum.inl y)

tactic: simp [Pso, indefiniteDiagonal]
state_before: case a.h.inl.inr
n : Type ?u.36435
p : Type u_1
q : Type u_2
l : Type ?u.36444
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x : p
y : q
⊢ (Pso p q R i * Pso p q R (-i)) (Sum.inl x) (Sum.inr y) = OfNat.ofNat 1 (Sum.inl x) (Sum.inr y)

tactic: simp [Pso, indefiniteDiagonal]
state_before: case a.h.inr.inl
n : Type ?u.36435
p : Type u_1
q : Type u_2
l : Type ?u.36444
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x : q
y : p
⊢ (Pso p q R i * Pso p q R (-i)) (Sum.inr x) (Sum.inl y) = OfNat.ofNat 1 (Sum.inr x) (Sum.inl y)

tactic: by_cases h : x = y <;>
simp [Pso, indefiniteDiagonal, h, hi]
state_before: case a.h.inr.inr
n : Type ?u.36435
p : Type u_1
q : Type u_2
l : Type ?u.36444
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x y : q
⊢ (Pso p q R i * Pso p q R (-i)) (Sum.inr x) (Sum.inr y) = OfNat.ofNat 1 (Sum.inr x) (Sum.inr y)
Theorem: List.takeList_eq_takeListTR
File: Std/Data/List/Basic.lean

tactic: funext α xs ns
state_before: ⊢ @takeList = @takeListTR

tactic: simp [takeListTR]
state_before: case h.h.h
α : Type u_1
xs : List α
ns : List Nat
⊢ takeList xs ns = takeListTR xs ns

tactic: let rec go (acc) : ∀ ns xs, @takeListTR.go α ns xs acc =
    let (l, r) := xs.takeList ns; (acc.toList ++ l, r)
| [], xs => by simp [takeListTR.go, takeList]
| n::ns, xs => by simp [takeListTR.go, takeList, go _ ns]
state_before: case h.h.h
α : Type u_1
xs : List α
ns : List Nat
⊢ takeList xs ns = takeListTR.go ns xs #[]

tactic: simp [takeListTR, go]
state_before: case h.h.h
α : Type u_1
xs : List α
ns : List Nat
⊢ takeList xs ns = takeListTR.go ns xs #[]

tactic: simp [takeListTR.go, takeList]
state_before: α : Type u_1
xs✝ : List α
ns : List Nat
acc : Array (List α)
xs : List α
⊢ takeListTR.go [] xs acc =
    match takeList xs [] with
    | (l, r) => (Array.toList acc ++ l, r)

tactic: simp [takeListTR.go, takeList, go _ ns]
state_before: α : Type u_1
xs✝ : List α
ns✝ : List Nat
acc : Array (List α)
n : Nat
ns : List Nat
xs : List α
⊢ takeListTR.go (n :: ns) xs acc =
    match takeList xs (n :: ns) with
    | (l, r) => (Array.toList acc ++ l, r)
Theorem: AffineSubspace.coe_affineSpan_singleton
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: ext x
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
⊢ ↑(affineSpan k {p}) = {p}

tactic: rw [mem_coe, ← vsub_right_mem_direction_iff_mem (mem_affineSpan k (Set.mem_singleton p)) _,
  direction_affineSpan]
state_before: case h
k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p x : P
⊢ x ∈ ↑(affineSpan k {p}) ↔ x ∈ {p}

tactic: simp
state_before: case h
k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p x : P
⊢ x -ᵥ p ∈ vectorSpan k {p} ↔ x ∈ {p}
Theorem: Sylow.ext
File: Mathlib/GroupTheory/Sylow.lean

tactic: cases P
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
P Q : Sylow p G
h : ↑P = ↑Q
⊢ P = Q

tactic: cases Q
state_before: case mk
p : ℕ
G : Type u_1
inst✝ : Group G
Q : Sylow p G
toSubgroup✝ : Subgroup G
isPGroup'✝ : IsPGroup p { x // x ∈ toSubgroup✝ }
is_maximal'✝ : ∀ {Q : Subgroup G}, IsPGroup p { x // x ∈ Q } → toSubgroup✝ ≤ Q → Q = toSubgroup✝
h : ↑{ toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ } = ↑Q
⊢ { toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ } = Q

tactic: congr
state_before: case mk.mk
p : ℕ
G : Type u_1
inst✝ : Group G
toSubgroup✝¹ : Subgroup G
isPGroup'✝¹ : IsPGroup p { x // x ∈ toSubgroup✝¹ }
is_maximal'✝¹ : ∀ {Q : Subgroup G}, IsPGroup p { x // x ∈ Q } → toSubgroup✝¹ ≤ Q → Q = toSubgroup✝¹
toSubgroup✝ : Subgroup G
isPGroup'✝ : IsPGroup p { x // x ∈ toSubgroup✝ }
is_maximal'✝ : ∀ {Q : Subgroup G}, IsPGroup p { x // x ∈ Q } → toSubgroup✝ ≤ Q → Q = toSubgroup✝
h :
  ↑{ toSubgroup := toSubgroup✝¹, isPGroup' := isPGroup'✝¹, is_maximal' := is_maximal'✝¹ } =
    ↑{ toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ }
⊢ { toSubgroup := toSubgroup✝¹, isPGroup' := isPGroup'✝¹, is_maximal' := is_maximal'✝¹ } =
    { toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ }
Theorem: CharTwo.sub_eq_add
File: Mathlib/Algebra/CharP/Two.lean

tactic: rw [sub_eq_add_neg, neg_eq]
state_before: R : Type u_1
ι : Type ?u.7549
inst✝¹ : Ring R
inst✝ : CharP R 2
x y : R
⊢ x - y = x + y
Theorem: mul_neg_one
File: Mathlib/Algebra/Ring/Defs.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : MulOneClass α
inst✝ : HasDistribNeg α
a : α
⊢ a * -1 = -a
Theorem: norm_image_sub_le_of_norm_deriv_le_segment_01
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: simpa only [sub_zero, mul_one] using
  norm_image_sub_le_of_norm_deriv_le_segment hf bound 1 (right_mem_Icc.2 zero_le_one)
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.44608
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b C : ℝ
hf : DifferentiableOn ℝ f (Icc 0 1)
bound : ∀ (x : ℝ), x ∈ Ico 0 1 → ‖derivWithin f (Icc 0 1) x‖ ≤ C
⊢ ‖f 1 - f 0‖ ≤ C
Theorem: Int.fract_eq_self
File: Mathlib/Algebra/Order/Floor.lean

tactic: simp
state_before: F : Type ?u.165723
α : Type u_1
β : Type ?u.165729
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ a - a = ↑0
Theorem: BilinForm.IsAdjointPair.mul
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [LinearMap.mul_apply, LinearMap.mul_apply, h, h']
state_before: R : Type u_1
M : Type u_2
inst✝²⁴ : Semiring R
inst✝²³ : AddCommMonoid M
inst✝²² : Module R M
R₁ : Type ?u.1104318
M₁ : Type ?u.1104321
inst✝²¹ : Ring R₁
inst✝²⁰ : AddCommGroup M₁
inst✝¹⁹ : Module R₁ M₁
R₂ : Type ?u.1104930
M₂ : Type ?u.1104933
inst✝¹⁸ : CommSemiring R₂
inst✝¹⁷ : AddCommMonoid M₂
inst✝¹⁶ : Module R₂ M₂
R₃ : Type ?u.1105120
M₃ : Type ?u.1105123
inst✝¹⁵ : CommRing R₃
inst✝¹⁴ : AddCommGroup M₃
inst✝¹³ : Module R₃ M₃
V : Type ?u.1105711
K : Type ?u.1105714
inst✝¹² : Field K
inst✝¹¹ : AddCommGroup V
inst✝¹⁰ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.1106928
M₂'' : Type ?u.1106931
inst✝⁹ : AddCommMonoid M₂'
inst✝⁸ : AddCommMonoid M₂''
inst✝⁷ : Module R₂ M₂'
inst✝⁶ : Module R₂ M₂''
F : BilinForm R M
M' : Type ?u.1107242
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : Module R M'
B' : BilinForm R M'
f✝ f'✝ : M →ₗ[R] M'
g✝ g'✝ : M' →ₗ[R] M
M₁' : Type ?u.1107679
inst✝³ : AddCommGroup M₁'
inst✝² : Module R₁ M₁'
B₁' : BilinForm R₁ M₁'
f₁ f₁' : M₁ →ₗ[R₁] M₁'
g₁ g₁' : M₁' →ₗ[R₁] M₁
B₂' : BilinForm R₂ M₂'
f₂ f₂' : M₂ →ₗ[R₂] M₂'
g₂ g₂' : M₂' →ₗ[R₂] M₂
M'' : Type ?u.1110158
inst✝¹ : AddCommMonoid M''
inst✝ : Module R M''
B'' : BilinForm R M''
f g f' g' : Module.End R M
h : IsAdjointPair B B f g
h' : IsAdjointPair B B f' g'
x y : M
⊢ bilin B (↑(f * f') x) y = bilin B x (↑(g' * g) y)
Theorem: Equiv.swapCore_comm
File: Mathlib/Logic/Equiv/Basic.lean

tactic: unfold swapCore
state_before: α : Sort u_1
inst✝ : DecidableEq α
r a b : α
⊢ swapCore a b r = swapCore b a r

tactic: split_ifs with h₁ h₂ h₃ <;> simp
state_before: α : Sort u_1
inst✝ : DecidableEq α
r a b : α
⊢ (if r = a then b else if r = b then a else r) = if r = b then a else if r = a then b else r

tactic: cases h₁
state_before: case inl.inl
α : Sort u_1
inst✝ : DecidableEq α
r a b : α
h₁ : r = a
h₂ : r = b
⊢ b = a

tactic: cases h₂
state_before: case inl.inl.refl
α : Sort u_1
inst✝ : DecidableEq α
r b : α
h₂ : r = b
⊢ b = r

tactic: rfl
state_before: case inl.inl.refl.refl
α : Sort u_1
inst✝ : DecidableEq α
r : α
⊢ r = r
Theorem: IsAntichain.ordConnected
File: Mathlib/Data/Set/Intervals/OrdConnected.lean

tactic: obtain rfl := hs.eq hx hy (hz.1.trans hz.2)
state_before: α : Type u_1
inst✝ : PartialOrder α
s : Set α
hs : IsAntichain (fun x x_1 => x ≤ x_1) s
x : α
hx : x ∈ s
y : α
hy : y ∈ s
z : α
hz : z ∈ Icc x y
⊢ z ∈ s

tactic: rw [Icc_self, mem_singleton_iff] at hz
state_before: α : Type u_1
inst✝ : PartialOrder α
s : Set α
hs : IsAntichain (fun x x_1 => x ≤ x_1) s
x : α
hx : x ∈ s
z : α
hy : x ∈ s
hz : z ∈ Icc x x
⊢ z ∈ s

tactic: rwa [hz]
state_before: α : Type u_1
inst✝ : PartialOrder α
s : Set α
hs : IsAntichain (fun x x_1 => x ≤ x_1) s
x : α
hx : x ∈ s
z : α
hy : x ∈ s
hz : z = x
⊢ z ∈ s
Theorem: IsROrC.abs_im_le_norm
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [mul_self_le_mul_self_iff (abs_nonneg _) (norm_nonneg _), abs_mul_abs_self, mul_self_norm]
state_before: K : Type u_1
E : Type ?u.6631852
inst✝ : IsROrC K
z : K
⊢ abs (↑im z) ≤ ‖z‖

tactic: apply im_sq_le_normSq
state_before: K : Type u_1
E : Type ?u.6631852
inst✝ : IsROrC K
z : K
⊢ ↑im z * ↑im z ≤ ↑normSq z
Theorem: Finset.Iio_subset_Iic_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simpa [← coe_subset] using Set.Iio_subset_Iic_self
state_before: ι : Type ?u.66687
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrderBot α
a : α
⊢ Iio a ⊆ Iic a
Theorem: Primrec.encode_iff
File: Mathlib/Computability/Primrec.lean

tactic: cases @decode α _ n <;> rfl
state_before: α : Type u_1
β : Type ?u.25349
σ : Type u_2
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α → σ
h : Primrec fun a => encode (f a)
n : ℕ
⊢ encode (Option.map (fun a => encode (f a)) (decode n)) = encode (Option.map f (decode n))
Theorem: Int.ediv_zero
File: Std/Data/Int/DivMod.lean

tactic: simp
state_before: a✝ : Nat
⊢ ofNat (a✝ / 0) = 0
Theorem: Nat.coprime_or_dvd_of_prime
File: Mathlib/Data/Nat/Prime.lean

tactic: rw [pp.dvd_iff_not_coprime]
state_before: p : ℕ
pp : Prime p
i : ℕ
⊢ coprime p i ∨ p ∣ i

tactic: apply em
state_before: p : ℕ
pp : Prime p
i : ℕ
⊢ coprime p i ∨ ¬coprime p i
Theorem: nhds_top_basis
File: Mathlib/Topology/Order/Basic.lean

tactic: have : ∃ x : α, x < ⊤ := (exists_ne ⊤).imp fun x hx => hx.lt_top
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTop α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
⊢ HasBasis (𝓝 ⊤) (fun a => a < ⊤) fun a => Ioi a

tactic: simpa only [Iic_top, nhdsWithin_univ, Ioc_top] using nhdsWithin_Iic_basis' this
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTop α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
this : ∃ x, x < ⊤
⊢ HasBasis (𝓝 ⊤) (fun a => a < ⊤) fun a => Ioi a
Theorem: OnePoint.coe_preimage_infty
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: ext
state_before: X : Type u_1
⊢ some ⁻¹' {∞} = ∅

tactic: simp
state_before: case h
X : Type u_1
x✝ : X
⊢ x✝ ∈ some ⁻¹' {∞} ↔ x✝ ∈ ∅
Theorem: Nat.one_le_cast
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: rw [← cast_one, cast_le]
state_before: α : Type u_1
β : Type ?u.18685
inst✝¹ : OrderedSemiring α
inst✝ : CharZero α
m n : ℕ
⊢ 1 ≤ ↑n ↔ 1 ≤ n
Theorem: hasFDerivAt_of_tendsto_locally_uniformly_on'
File: Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean

tactic: refine' hasFDerivAt_of_tendstoLocallyUniformlyOn hs hf' (fun n z hz => _) hfg hx
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
s : Set E
hs : IsOpen s
hf' : TendstoLocallyUniformlyOn (fderiv 𝕜 ∘ f) g' l s
hf : ∀ (n : ι), DifferentiableOn 𝕜 (f n) s
hfg : ∀ (x : E), x ∈ s → Tendsto (fun n => f n x) l (𝓝 (g x))
hx : x ∈ s
⊢ HasFDerivAt g (g' x) x

tactic: exact ((hf n z hz).differentiableAt (hs.mem_nhds hz)).hasFDerivAt
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
s : Set E
hs : IsOpen s
hf' : TendstoLocallyUniformlyOn (fderiv 𝕜 ∘ f) g' l s
hf : ∀ (n : ι), DifferentiableOn 𝕜 (f n) s
hfg : ∀ (x : E), x ∈ s → Tendsto (fun n => f n x) l (𝓝 (g x))
hx : x ∈ s
n : ι
z : E
hz : z ∈ s
⊢ HasFDerivAt (fun x => f n x) ((fderiv 𝕜 ∘ f) n z) z