tasksource/leandojo huggingface dataset:
Theorem: RingHom.Finite.of_comp_finite
File: Mathlib/RingTheory/Finiteness.lean

tactic: letI := f.toAlgebra
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
h : Finite (RingHom.comp g f)
⊢ Finite g

tactic: letI := g.toAlgebra
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
h : Finite (RingHom.comp g f)
this : Algebra A B := toAlgebra f
⊢ Finite g

tactic: letI := (g.comp f).toAlgebra
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
h : Finite (RingHom.comp g f)
this✝ : Algebra A B := toAlgebra f
this : Algebra B C := toAlgebra g
⊢ Finite g

tactic: letI : IsScalarTower A B C := RestrictScalars.isScalarTower A B C
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
h : Finite (RingHom.comp g f)
this✝¹ : Algebra A B := toAlgebra f
this✝ : Algebra B C := toAlgebra g
this : Algebra A C := toAlgebra (RingHom.comp g f)
⊢ Finite g

tactic: letI : Module.Finite A C := h
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
h : Finite (RingHom.comp g f)
this✝² : Algebra A B := toAlgebra f
this✝¹ : Algebra B C := toAlgebra g
this✝ : Algebra A C := toAlgebra (RingHom.comp g f)
this : IsScalarTower A B C := RestrictScalars.isScalarTower A B C
⊢ Finite g

tactic: exact Module.Finite.of_restrictScalars_finite A B C
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
g : B →+* C
h : Finite (RingHom.comp g f)
this✝³ : Algebra A B := toAlgebra f
this✝² : Algebra B C := toAlgebra g
this✝¹ : Algebra A C := toAlgebra (RingHom.comp g f)
this✝ : IsScalarTower A B C := RestrictScalars.isScalarTower A B C
this : Module.Finite A C := h
⊢ Finite g
Theorem: List.sublist_or_mem_of_sublist
File: Std/Data/List/Lemmas.lean

tactic: induction l₁ generalizing l with
| nil => match h with
  | .cons _ h => exact .inl h
  | .cons₂ _ h => exact .inr (.head ..)
| cons b l₁ IH =>
  match h with
  | .cons _ h => exact (IH h).imp_left (Sublist.cons _)
  | .cons₂ _ h => exact (IH h).imp (Sublist.cons₂ _) (.tail _)
state_before: α✝ : Type u_1
l l₁ : List α✝
a : α✝
l₂ : List α✝
h : l <+ l₁ ++ a :: l₂
⊢ l <+ l₁ ++ l₂ ∨ a ∈ l

tactic: match h with
| .cons _ h => exact .inl h
| .cons₂ _ h => exact .inr (.head ..)
state_before: case nil
α✝ : Type u_1
a : α✝
l₂ l : List α✝
h : l <+ [] ++ a :: l₂
⊢ l <+ [] ++ l₂ ∨ a ∈ l

tactic: exact .inl h
state_before: α✝ : Type u_1
a : α✝
l₂ l✝ : List α✝
h✝ : l✝ <+ [] ++ a :: l₂
l : List α✝
h : l <+ l₂
⊢ l <+ [] ++ l₂ ∨ a ∈ l

tactic: exact .inr (.head ..)
state_before: α✝ : Type u_1
a : α✝
l₂ l : List α✝
h✝ : l <+ [] ++ a :: l₂
l₁✝ : List α✝
h : l₁✝ <+ l₂
⊢ a :: l₁✝ <+ [] ++ l₂ ∨ a ∈ a :: l₁✝

tactic: match h with
| .cons _ h => exact (IH h).imp_left (Sublist.cons _)
| .cons₂ _ h => exact (IH h).imp (Sublist.cons₂ _) (.tail _)
state_before: case cons
α✝ : Type u_1
a : α✝
l₂ : List α✝
b : α✝
l₁ : List α✝
IH : ∀ {l : List α✝}, l <+ l₁ ++ a :: l₂ → l <+ l₁ ++ l₂ ∨ a ∈ l
l : List α✝
h : l <+ b :: l₁ ++ a :: l₂
⊢ l <+ b :: l₁ ++ l₂ ∨ a ∈ l

tactic: exact (IH h).imp_left (Sublist.cons _)
state_before: α✝ : Type u_1
a : α✝
l₂ : List α✝
b : α✝
l₁ : List α✝
IH : ∀ {l : List α✝}, l <+ l₁ ++ a :: l₂ → l <+ l₁ ++ l₂ ∨ a ∈ l
l✝ : List α✝
h✝ : l✝ <+ b :: l₁ ++ a :: l₂
l : List α✝
h : l <+ List.append l₁ (a :: l₂)
⊢ l <+ b :: l₁ ++ l₂ ∨ a ∈ l

tactic: exact (IH h).imp (Sublist.cons₂ _) (.tail _)
state_before: α✝ : Type u_1
a : α✝
l₂ : List α✝
b : α✝
l₁ : List α✝
IH : ∀ {l : List α✝}, l <+ l₁ ++ a :: l₂ → l <+ l₁ ++ l₂ ∨ a ∈ l
l : List α✝
h✝ : l <+ b :: l₁ ++ a :: l₂
l₁✝ : List α✝
h : l₁✝ <+ List.append l₁ (a :: l₂)
⊢ b :: l₁✝ <+ b :: l₁ ++ l₂ ∨ a ∈ b :: l₁✝
Theorem: algebraicIndependent_empty_type_iff
File: Mathlib/RingTheory/AlgebraicIndependent.lean

tactic: have : aeval x = (Algebra.ofId R A).comp (@isEmptyAlgEquiv R ι _ _).toAlgHom := by
  ext i
  exact IsEmpty.elim' ‹IsEmpty ι› i
state_before: ι : Type u_1
ι' : Type ?u.74821
R : Type u_2
K : Type ?u.74827
A : Type u_3
A' : Type ?u.74833
A'' : Type ?u.74836
V : Type u
V' : Type ?u.74841
x : ι → A
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : CommRing A'
inst✝⁴ : CommRing A''
inst✝³ : Algebra R A
inst✝² : Algebra R A'
inst✝¹ : Algebra R A''
a b : R
inst✝ : IsEmpty ι
⊢ AlgebraicIndependent R x ↔ Injective ↑(algebraMap R A)

tactic: rw [AlgebraicIndependent, this, ← Injective.of_comp_iff' _ (@isEmptyAlgEquiv R ι _ _).bijective]
state_before: ι : Type u_1
ι' : Type ?u.74821
R : Type u_2
K : Type ?u.74827
A : Type u_3
A' : Type ?u.74833
A'' : Type ?u.74836
V : Type u
V' : Type ?u.74841
x : ι → A
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : CommRing A'
inst✝⁴ : CommRing A''
inst✝³ : Algebra R A
inst✝² : Algebra R A'
inst✝¹ : Algebra R A''
a b : R
inst✝ : IsEmpty ι
this : aeval x = AlgHom.comp (ofId R A) ↑(isEmptyAlgEquiv R ι)
⊢ AlgebraicIndependent R x ↔ Injective ↑(algebraMap R A)

tactic: rfl
state_before: ι : Type u_1
ι' : Type ?u.74821
R : Type u_2
K : Type ?u.74827
A : Type u_3
A' : Type ?u.74833
A'' : Type ?u.74836
V : Type u
V' : Type ?u.74841
x : ι → A
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : CommRing A'
inst✝⁴ : CommRing A''
inst✝³ : Algebra R A
inst✝² : Algebra R A'
inst✝¹ : Algebra R A''
a b : R
inst✝ : IsEmpty ι
this : aeval x = AlgHom.comp (ofId R A) ↑(isEmptyAlgEquiv R ι)
⊢ Injective ↑(AlgHom.comp (ofId R A) ↑(isEmptyAlgEquiv R ι)) ↔ Injective (↑(algebraMap R A) ∘ ↑(isEmptyAlgEquiv R ι))

tactic: ext i
state_before: ι : Type u_1
ι' : Type ?u.74821
R : Type u_2
K : Type ?u.74827
A : Type u_3
A' : Type ?u.74833
A'' : Type ?u.74836
V : Type u
V' : Type ?u.74841
x : ι → A
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : CommRing A'
inst✝⁴ : CommRing A''
inst✝³ : Algebra R A
inst✝² : Algebra R A'
inst✝¹ : Algebra R A''
a b : R
inst✝ : IsEmpty ι
⊢ aeval x = AlgHom.comp (ofId R A) ↑(isEmptyAlgEquiv R ι)

tactic: exact IsEmpty.elim' ‹IsEmpty ι› i
state_before: case hf
ι : Type u_1
ι' : Type ?u.74821
R : Type u_2
K : Type ?u.74827
A : Type u_3
A' : Type ?u.74833
A'' : Type ?u.74836
V : Type u
V' : Type ?u.74841
x : ι → A
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : CommRing A'
inst✝⁴ : CommRing A''
inst✝³ : Algebra R A
inst✝² : Algebra R A'
inst✝¹ : Algebra R A''
a b : R
inst✝ : IsEmpty ι
i : ι
⊢ ↑(aeval x) (X i) = ↑(AlgHom.comp (ofId R A) ↑(isEmptyAlgEquiv R ι)) (X i)
Theorem: List.next_prev
File: Mathlib/Data/List/Cycle.lean

tactic: obtain ⟨n, hn, rfl⟩ := nthLe_of_mem hx
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
h : Nodup l
x : α
hx : x ∈ l
⊢ next l (prev l x hx) (_ : prev l x hx ∈ l) = x

tactic: simp only [next_nthLe, prev_nthLe, h, Nat.mod_add_mod]
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : Nodup l
n : ℕ
hn : n < length l
hx : nthLe l n hn ∈ l
⊢ next l (prev l (nthLe l n hn) hx) (_ : prev l (nthLe l n hn) hx ∈ l) = nthLe l n hn

tactic: cases' l with hd tl
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : Nodup l
n : ℕ
hn : n < length l
hx : nthLe l n hn ∈ l
⊢ nthLe l ((n + (length l - 1) + 1) % length l) (_ : (n + (length l - 1) + 1) % length l < length l) = nthLe l n hn

tactic: simp at hx
state_before: case intro.intro.nil
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
n : ℕ
h : Nodup []
hn : n < length []
hx : nthLe [] n hn ∈ []
⊢ nthLe [] ((n + (length [] - 1) + 1) % length []) (_ : (n + (length [] - 1) + 1) % length [] < length []) =
    nthLe [] n hn

tactic: have : (n + length tl + 1) % (length tl + 1) = n := by
  rw [length_cons] at hn
  rw [add_assoc, Nat.add_mod_right, Nat.mod_eq_of_lt hn]
state_before: case intro.intro.cons
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
n : ℕ
hd : α
tl : List α
h : Nodup (hd :: tl)
hn : n < length (hd :: tl)
hx : nthLe (hd :: tl) n hn ∈ hd :: tl
⊢ nthLe (hd :: tl) ((n + (length (hd :: tl) - 1) + 1) % length (hd :: tl))
      (_ : (n + (length (hd :: tl) - 1) + 1) % length (hd :: tl) < length (hd :: tl)) =
    nthLe (hd :: tl) n hn

tactic: simp [this]
state_before: case intro.intro.cons
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
n : ℕ
hd : α
tl : List α
h : Nodup (hd :: tl)
hn : n < length (hd :: tl)
hx : nthLe (hd :: tl) n hn ∈ hd :: tl
this : (n + length tl + 1) % (length tl + 1) = n
⊢ nthLe (hd :: tl) ((n + (length (hd :: tl) - 1) + 1) % length (hd :: tl))
      (_ : (n + (length (hd :: tl) - 1) + 1) % length (hd :: tl) < length (hd :: tl)) =
    nthLe (hd :: tl) n hn

tactic: rw [length_cons] at hn
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
n : ℕ
hd : α
tl : List α
h : Nodup (hd :: tl)
hn : n < length (hd :: tl)
hx : nthLe (hd :: tl) n hn ∈ hd :: tl
⊢ (n + length tl + 1) % (length tl + 1) = n

tactic: rw [add_assoc, Nat.add_mod_right, Nat.mod_eq_of_lt hn]
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
n : ℕ
hd : α
tl : List α
h : Nodup (hd :: tl)
hn✝ : n < length (hd :: tl)
hn : n < Nat.succ (length tl)
hx : nthLe (hd :: tl) n hn✝ ∈ hd :: tl
⊢ (n + length tl + 1) % (length tl + 1) = n
Theorem: zpow_add_one
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: simp only [← Int.ofNat_succ, zpow_ofNat, pow_succ']
state_before: α : Type ?u.106815
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
a : G
n : ℕ
⊢ a ^ (↑n + 1) = a ^ ↑n * a

tactic: erw [zpow_zero, zpow_negSucc, pow_one, mul_left_inv]
state_before: α : Type ?u.106815
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
a : G
⊢ a ^ (-[0+1] + 1) = a ^ -[0+1] * a

tactic: rw [zpow_negSucc, pow_succ, mul_inv_rev, inv_mul_cancel_right]
state_before: α : Type ?u.106815
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
a : G
n : ℕ
⊢ a ^ (-[n + 1+1] + 1) = a ^ -[n + 1+1] * a

tactic: rw [Int.negSucc_eq, neg_add, add_assoc, neg_add_self, add_zero]
state_before: α : Type ?u.106815
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
a : G
n : ℕ
⊢ a ^ (-[n + 1+1] + 1) = (a ^ (n + 1))⁻¹

tactic: exact zpow_negSucc _ _
state_before: α : Type ?u.106815
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group G
a : G
n : ℕ
⊢ a ^ (-↑(n + 1)) = (a ^ (n + 1))⁻¹
Theorem: GroupWithZero.mul_left_injective
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: simpa only [← mul_assoc, inv_mul_cancel h, one_mul] using congr_arg (fun y => x⁻¹ * y) w
state_before: α : Type ?u.18039
M₀ : Type ?u.18042
G₀ : Type u_1
M₀' : Type ?u.18048
G₀' : Type ?u.18051
F : Type ?u.18054
F' : Type ?u.18057
inst✝ : GroupWithZero G₀
a b c g h✝ x : G₀
h : x ≠ 0
y y' : G₀
w : (fun y => x * y) y = (fun y => x * y) y'
⊢ y = y'
Theorem: Finset.subset_smul_finset_iff
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp_rw [← coe_subset]
state_before: F : Type ?u.841640
α : Type u_2
β : Type u_1
γ : Type ?u.841649
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ s ⊆ a • t ↔ a⁻¹ • s ⊆ t

tactic: push_cast
state_before: F : Type ?u.841640
α : Type u_2
β : Type u_1
γ : Type ?u.841649
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ ↑s ⊆ ↑(a • t) ↔ ↑(a⁻¹ • s) ⊆ ↑t

tactic: exact Set.subset_set_smul_iff
state_before: F : Type ?u.841640
α : Type u_2
β : Type u_1
γ : Type ?u.841649
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ ↑s ⊆ a • ↑t ↔ a⁻¹ • ↑s ⊆ ↑t
Theorem: order_eq_card_zpowers'
File: Mathlib/Data/ZMod/Quotient.lean

tactic: have := Nat.card_congr (MulAction.orbitZpowersEquiv a (1 : α))
state_before: n : ℕ
A : Type ?u.322503
R : Type ?u.322506
inst✝² : AddGroup A
inst✝¹ : Ring R
α : Type u_1
inst✝ : Group α
a : α
⊢ orderOf a = Nat.card { x // x ∈ zpowers a }

tactic: rwa [Nat.card_zmod, orbit_subgroup_one_eq_self, eq_comm] at this
state_before: n : ℕ
A : Type ?u.322503
R : Type ?u.322506
inst✝² : AddGroup A
inst✝¹ : Ring R
α : Type u_1
inst✝ : Group α
a : α
this :
  Nat.card ↑(MulAction.orbit { x // x ∈ zpowers a } 1) =
    Nat.card (ZMod (Function.minimalPeriod ((fun x x_1 => x • x_1) a) 1))
⊢ orderOf a = Nat.card { x // x ∈ zpowers a }
Theorem: Int.modEq_iff_add_fac
File: Mathlib/Data/Int/ModEq.lean

tactic: rw [modEq_iff_dvd]
state_before: m n✝ a✝ b✝ c d a b n : ℤ
⊢ a ≡ b [ZMOD n] ↔ ∃ t, b = a + n * t

tactic: exact exists_congr fun t => sub_eq_iff_eq_add'
state_before: m n✝ a✝ b✝ c d a b n : ℤ
⊢ n ∣ b - a ↔ ∃ t, b = a + n * t
Theorem: MulLECancellable.le_mul_iff_one_le_left
File: Mathlib/Algebra/Order/Monoid/Lemmas.lean

tactic: rw [mul_comm, ha.le_mul_iff_one_le_right]
state_before: α : Type u_1
β : Type ?u.88130
inst✝² : LE α
inst✝¹ : CommMonoid α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ha : MulLECancellable a
⊢ a ≤ b * a ↔ 1 ≤ b
Theorem: IntermediateField.Lifts.exists_max_two
File: Mathlib/FieldTheory/Adjoin.lean

tactic: cases' (hc.insert fun _ _ _ => Or.inl bot_le).total hx hy with hxy hyx
state_before: F : Type u_3
E : Type u_2
K : Type u_1
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
c : Set (Lifts F E K)
x y : Lifts F E K
hc : IsChain (fun x x_1 => x ≤ x_1) c
hx : x ∈ insert ⊥ c
hy : y ∈ insert ⊥ c
⊢ ∃ z, z ∈ insert ⊥ c ∧ x ≤ z ∧ y ≤ z

tactic: exact ⟨y, hy, hxy, le_refl y⟩
state_before: case inl
F : Type u_3
E : Type u_2
K : Type u_1
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
c : Set (Lifts F E K)
x y : Lifts F E K
hc : IsChain (fun x x_1 => x ≤ x_1) c
hx : x ∈ insert ⊥ c
hy : y ∈ insert ⊥ c
hxy : x ≤ y
⊢ ∃ z, z ∈ insert ⊥ c ∧ x ≤ z ∧ y ≤ z

tactic: exact ⟨x, hx, le_refl x, hyx⟩
state_before: case inr
F : Type u_3
E : Type u_2
K : Type u_1
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
c : Set (Lifts F E K)
x y : Lifts F E K
hc : IsChain (fun x x_1 => x ≤ x_1) c
hx : x ∈ insert ⊥ c
hy : y ∈ insert ⊥ c
hyx : y ≤ x
⊢ ∃ z, z ∈ insert ⊥ c ∧ x ≤ z ∧ y ≤ z
Theorem: Std.PairingHeapImp.Heap.noSibling_deleteMin
File: Std/Data/PairingHeap.lean

tactic: cases s with cases eq | node a c => exact noSibling_combine _ _
state_before: α : Type u_1
le : α → α → Bool
a : α
s' s : Heap α
eq : deleteMin le s = some (a, s')
⊢ NoSibling s'

tactic: exact noSibling_combine _ _
state_before: case node.refl
α : Type u_1
le : α → α → Bool
a : α
c sibling✝ : Heap α
⊢ NoSibling (combine le c)
Theorem: Complex.closure_setOf_lt_im
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [closure_Ioi] using closure_preimage_im (Ioi a)
state_before: a : ℝ
⊢ closure {z | a < z.im} = {z | a ≤ z.im}
Theorem: Sylow.ne_bot_of_dvd_card
File: Mathlib/GroupTheory/Sylow.lean

tactic: refine' fun h => hp.out.not_dvd_one _
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p : ℕ
hp : Fact (Nat.Prime p)
P : Sylow p G
hdvd : p ∣ Fintype.card G
⊢ ↑P ≠ ⊥

tactic: have key : p ∣ card (P : Subgroup G) := P.dvd_card_of_dvd_card hdvd
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p : ℕ
hp : Fact (Nat.Prime p)
P : Sylow p G
hdvd : p ∣ Fintype.card G
h : ↑P = ⊥
⊢ p ∣ 1

tactic: rwa [h, card_bot] at key
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p : ℕ
hp : Fact (Nat.Prime p)
P : Sylow p G
hdvd : p ∣ Fintype.card G
h : ↑P = ⊥
key : p ∣ Fintype.card { x // x ∈ ↑P }
⊢ p ∣ 1
Theorem: IsSelfAdjoint.bit1
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [isSelfAdjoint_iff, star_bit1, hx.star_eq]
state_before: R : Type u_1
A : Type ?u.36077
inst✝¹ : Semiring R
inst✝ : StarRing R
x : R
hx : IsSelfAdjoint x
⊢ IsSelfAdjoint (_root_.bit1 x)
Theorem: im_inner_eq_norm_sub_i_smul_mul_self_sub_norm_add_i_smul_mul_self_div_four
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [@norm_add_mul_self 𝕜, @norm_sub_mul_self 𝕜, inner_smul_right, I_mul_re]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2621009
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) = (‖x - I • y‖ * ‖x - I • y‖ - ‖x + I • y‖ * ‖x + I • y‖) / 4

tactic: ring
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2621009
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) =
    (‖x‖ * ‖x‖ - 2 * -↑im (inner x y) + ‖I • y‖ * ‖I • y‖ - (‖x‖ * ‖x‖ + 2 * -↑im (inner x y) + ‖I • y‖ * ‖I • y‖)) / 4
Theorem: ZFSet.toSet_inter
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: change (ZFSet.sep (fun z => z ∈ y) x).toSet = _
state_before: x y : ZFSet
⊢ toSet (x ∩ y) = toSet x ∩ toSet y

tactic: ext
state_before: x y : ZFSet
⊢ toSet (ZFSet.sep (fun z => z ∈ y) x) = toSet x ∩ toSet y

tactic: simp
state_before: case h
x y x✝ : ZFSet
⊢ x✝ ∈ toSet (ZFSet.sep (fun z => z ∈ y) x) ↔ x✝ ∈ toSet x ∩ toSet y
Theorem: Set.zero_mul_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: simp [subset_def, mem_mul]
state_before: F : Type ?u.100096
α : Type u_1
β : Type ?u.100102
γ : Type ?u.100105
inst✝ : MulZeroClass α
s✝ t s : Set α
⊢ 0 * s ⊆ 0
Theorem: MeasureTheory.ae_eq_univ_iff_measure_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: refine' ⟨measure_congr, fun h => _⟩
state_before: α : Type u_1
β : Type ?u.646530
γ : Type ?u.646533
δ : Type ?u.646536
ι : Type ?u.646539
R : Type ?u.646542
R' : Type ?u.646545
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : IsFiniteMeasure μ
hs : NullMeasurableSet s
⊢ s =ᶠ[ae μ] univ ↔ ↑↑μ s = ↑↑μ univ

tactic: obtain ⟨t, -, ht₁, ht₂⟩ := hs.exists_measurable_subset_ae_eq
state_before: α : Type u_1
β : Type ?u.646530
γ : Type ?u.646533
δ : Type ?u.646536
ι : Type ?u.646539
R : Type ?u.646542
R' : Type ?u.646545
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : IsFiniteMeasure μ
hs : NullMeasurableSet s
h : ↑↑μ s = ↑↑μ univ
⊢ s =ᶠ[ae μ] univ

tactic: exact
  ht₂.symm.trans
    (ae_eq_of_subset_of_measure_ge (subset_univ t) (Eq.le ((measure_congr ht₂).trans h).symm) ht₁
      (measure_ne_top μ univ))
state_before: case intro.intro.intro
α : Type u_1
β : Type ?u.646530
γ : Type ?u.646533
δ : Type ?u.646536
ι : Type ?u.646539
R : Type ?u.646542
R' : Type ?u.646545
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
inst✝ : IsFiniteMeasure μ
hs : NullMeasurableSet s
h : ↑↑μ s = ↑↑μ univ
t : Set α
ht₁ : MeasurableSet t
ht₂ : t =ᶠ[ae μ] s
⊢ s =ᶠ[ae μ] univ
Theorem: codisjoint_hnot_hnot_right_iff
File: Mathlib/Order/Heyting/Basic.lean

tactic: simp_rw [← hnot_le_iff_codisjoint_left, hnot_hnot_hnot]
state_before: ι : Type ?u.178078
α : Type u_1
β : Type ?u.178084
inst✝ : CoheytingAlgebra α
a b c : α
⊢ Codisjoint a (￢￢b) ↔ Codisjoint a b
Theorem: PNat.XgcdType.flip_isSpecial
File: Mathlib/Data/PNat/Xgcd.lean

tactic: dsimp [IsSpecial, flip]
state_before: u : XgcdType
⊢ IsSpecial (flip u) ↔ IsSpecial u

tactic: rw [mul_comm u.x, mul_comm u.zp, add_comm u.zp]
state_before: u : XgcdType
⊢ u.zp + u.wp + u.zp * u.wp = u.y * u.x ↔ u.wp + u.zp + u.wp * u.zp = u.x * u.y
Theorem: Set.pi_univ_Ici
File: Mathlib/Data/Set/Intervals/Pi.lean

tactic: simp [Pi.le_def]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → Preorder (α i)
x y✝ y : (i : ι) → α i
⊢ (y ∈ pi univ fun i => Ici (x i)) ↔ y ∈ Ici x
Theorem: Nat.sub_le_iff_le_add'
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.sub_le_iff_le_add, Nat.add_comm]
state_before: a b c : Nat
⊢ a - b ≤ c ↔ a ≤ b + c
Theorem: CategoryTheory.unitCompPartialBijective_symm_apply
File: Mathlib/CategoryTheory/Adjunction/Reflective.lean

tactic: simp [unitCompPartialBijective, unitCompPartialBijectiveAux_symm_apply]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
i : D ⥤ C
inst✝ : Reflective i
A B : C
hB : B ∈ Functor.essImage i
f : i.obj ((leftAdjoint i).obj A) ⟶ B
⊢ ↑(unitCompPartialBijective A hB).symm f = (ofRightAdjoint i).unit.app A ≫ f
Theorem: finprod_curry
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: have h₁ : ∀ a, (∏ᶠ _ : a ∈ hf.toFinset, f a) = f a := by simp
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.456339
G : Type ?u.456342
M : Type u_3
N : Type ?u.456348
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : Set.Finite (mulSupport f)
⊢ (∏ᶠ (ab : α × β), f ab) = ∏ᶠ (a : α) (b : β), f (a, b)

tactic: have h₂ : (∏ᶠ a, f a) = ∏ᶠ (a) (_ : a ∈ hf.toFinset), f a := by simp
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.456339
G : Type ?u.456342
M : Type u_3
N : Type ?u.456348
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : Set.Finite (mulSupport f)
h₁ : ∀ (a : α × β), (∏ᶠ (_ : a ∈ Finite.toFinset hf), f a) = f a
⊢ (∏ᶠ (ab : α × β), f ab) = ∏ᶠ (a : α) (b : β), f (a, b)

tactic: simp_rw [h₂, finprod_mem_finset_product, h₁]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.456339
G : Type ?u.456342
M : Type u_3
N : Type ?u.456348
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : Set.Finite (mulSupport f)
h₁ : ∀ (a : α × β), (∏ᶠ (_ : a ∈ Finite.toFinset hf), f a) = f a
h₂ : (∏ᶠ (a : α × β), f a) = ∏ᶠ (a : α × β) (_ : a ∈ Finite.toFinset hf), f a
⊢ (∏ᶠ (ab : α × β), f ab) = ∏ᶠ (a : α) (b : β), f (a, b)

tactic: simp
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.456339
G : Type ?u.456342
M : Type u_3
N : Type ?u.456348
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : Set.Finite (mulSupport f)
⊢ ∀ (a : α × β), (∏ᶠ (_ : a ∈ Finite.toFinset hf), f a) = f a

tactic: simp
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.456339
G : Type ?u.456342
M : Type u_3
N : Type ?u.456348
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : Set.Finite (mulSupport f)
h₁ : ∀ (a : α × β), (∏ᶠ (_ : a ∈ Finite.toFinset hf), f a) = f a
⊢ (∏ᶠ (a : α × β), f a) = ∏ᶠ (a : α × β) (_ : a ∈ Finite.toFinset hf), f a
Theorem: Function.Semiconj.comp_right
File: Mathlib/Logic/Function/Conjugate.lean

tactic: simp only [comp_apply, h.eq, h'.eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.314
f fab : α → β
fbc : β → γ
ga ga' : α → α
gb gb' : β → β
gc gc' : γ → γ
h : Semiconj f ga gb
h' : Semiconj f ga' gb'
x : α
⊢ f ((ga ∘ ga') x) = (gb ∘ gb') (f x)
Theorem: nhdsWithin_pos_comap_mul_left
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: rw [nhdsWithin, comap_inf, comap_principal, preimage_const_mul_Ioi _ hx, zero_div]
state_before: 𝕜 : Type u_1
α : Type ?u.51715
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
x : 𝕜
hx : 0 < x
⊢ comap (fun x_1 => x * x_1) (𝓝[Ioi 0] 0) = 𝓝[Ioi 0] 0

tactic: congr 1
state_before: 𝕜 : Type u_1
α : Type ?u.51715
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
x : 𝕜
hx : 0 < x
⊢ comap (fun x_1 => x * x_1) (𝓝 0) ⊓ 𝓟 (Ioi 0) = 𝓝 0 ⊓ 𝓟 (Ioi 0)

tactic: refine ((Homeomorph.mulLeft₀ x hx.ne').comap_nhds_eq _).trans ?_
state_before: case e_a
𝕜 : Type u_1
α : Type ?u.51715
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
x : 𝕜
hx : 0 < x
⊢ comap (fun x_1 => x * x_1) (𝓝 0) = 𝓝 0

tactic: simp
state_before: case e_a
𝕜 : Type u_1
α : Type ?u.51715
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
x : 𝕜
hx : 0 < x
⊢ 𝓝 (↑(Homeomorph.symm (Homeomorph.mulLeft₀ x (_ : x ≠ 0))) 0) = 𝓝 0