tasksource/leandojo huggingface dataset:
Theorem: Finset.prod_apply_ite_of_false
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp_rw [apply_ite k]
state_before: ι : Type ?u.407012
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
f g : α → γ
k : γ → β
h : ∀ (x : α), x ∈ s → ¬p x
⊢ ∏ x in s, k (if p x then f x else g x) = ∏ x in s, k (g x)

tactic: exact prod_ite_of_false _ _ h
state_before: ι : Type ?u.407012
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
f g : α → γ
k : γ → β
h : ∀ (x : α), x ∈ s → ¬p x
⊢ (∏ x in s, if p x then k (f x) else k (g x)) = ∏ x in s, k (g x)
Theorem: Matrix.det_invOf
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: letI := detInvertibleOfInvertible A
state_before: l : Type ?u.48132
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Invertible A
inst✝ : Invertible (det A)
⊢ det ⅟A = ⅟(det A)

tactic: convert(rfl : _ = ⅟ A.det)
state_before: l : Type ?u.48132
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Invertible A
inst✝ : Invertible (det A)
this : Invertible (det A) := detInvertibleOfInvertible A
⊢ det ⅟A = ⅟(det A)
Theorem: Int.zpow_log_le_self
File: Mathlib/Data/Int/Log.lean

tactic: cases' le_total 1 r with hr1 hr1
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
⊢ ↑b ^ log b r ≤ r

tactic: rw [log_of_one_le_right _ hr1]
state_before: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : 1 ≤ r
⊢ ↑b ^ log b r ≤ r

tactic: rw [zpow_ofNat, ← Nat.cast_pow, ← Nat.le_floor_iff hr.le]
state_before: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : 1 ≤ r
⊢ ↑b ^ ↑(Nat.log b ⌊r⌋₊) ≤ r

tactic: exact Nat.pow_log_le_self b (Nat.floor_pos.mpr hr1).ne'
state_before: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : 1 ≤ r
⊢ b ^ Nat.log b ⌊r⌋₊ ≤ ⌊r⌋₊

tactic: rw [log_of_right_le_one _ hr1, zpow_neg, zpow_ofNat, ← Nat.cast_pow]
state_before: case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : r ≤ 1
⊢ ↑b ^ log b r ≤ r

tactic: exact inv_le_of_inv_le hr (Nat.ceil_le.1 <| Nat.le_pow_clog hb _)
state_before: case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
hr1 : r ≤ 1
⊢ (↑(b ^ Nat.clog b ⌈r⁻¹⌉₊))⁻¹ ≤ r
Theorem: dense_iInter_of_open
File: Mathlib/Topology/MetricSpace/Baire.lean

tactic: rw [← sInter_range]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.14090
ι : Type ?u.14093
inst✝² : TopologicalSpace α
inst✝¹ : BaireSpace α
inst✝ : Encodable β
f : β → Set α
ho : ∀ (s : β), IsOpen (f s)
hd : ∀ (s : β), Dense (f s)
⊢ Dense (⋂ (s : β), f s)

tactic: apply dense_sInter_of_open
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.14090
ι : Type ?u.14093
inst✝² : TopologicalSpace α
inst✝¹ : BaireSpace α
inst✝ : Encodable β
f : β → Set α
ho : ∀ (s : β), IsOpen (f s)
hd : ∀ (s : β), Dense (f s)
⊢ Dense (⋂₀ range fun s => f s)

tactic: rwa [forall_range_iff]
state_before: case ho
α : Type u_2
β : Type u_1
γ : Type ?u.14090
ι : Type ?u.14093
inst✝² : TopologicalSpace α
inst✝¹ : BaireSpace α
inst✝ : Encodable β
f : β → Set α
ho : ∀ (s : β), IsOpen (f s)
hd : ∀ (s : β), Dense (f s)
⊢ ∀ (s : Set α), (s ∈ range fun s => f s) → IsOpen s

tactic: exact countable_range _
state_before: case hS
α : Type u_2
β : Type u_1
γ : Type ?u.14090
ι : Type ?u.14093
inst✝² : TopologicalSpace α
inst✝¹ : BaireSpace α
inst✝ : Encodable β
f : β → Set α
ho : ∀ (s : β), IsOpen (f s)
hd : ∀ (s : β), Dense (f s)
⊢ Set.Countable (range fun s => f s)

tactic: rwa [forall_range_iff]
state_before: case hd
α : Type u_2
β : Type u_1
γ : Type ?u.14090
ι : Type ?u.14093
inst✝² : TopologicalSpace α
inst✝¹ : BaireSpace α
inst✝ : Encodable β
f : β → Set α
ho : ∀ (s : β), IsOpen (f s)
hd : ∀ (s : β), Dense (f s)
⊢ ∀ (s : Set α), (s ∈ range fun s => f s) → Dense s
Theorem: Multiset.gcd_ndunion
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: rw [← gcd_dedup, dedup_ext.2, gcd_dedup, gcd_add]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ gcd (ndunion s₁ s₂) = GCDMonoid.gcd (gcd s₁) (gcd s₂)

tactic: simp
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ ndunion s₁ s₂ ↔ a ∈ s₁ + s₂
Theorem: preimage_nhdsWithin_coinduced'
File: Mathlib/Topology/ContinuousOn.lean

tactic: lift a to t using h
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.8061
δ : Type ?u.8064
inst✝ : TopologicalSpace α
π : α → β
s : Set β
t : Set α
a : α
h : a ∈ t
hs : s ∈ 𝓝 (π a)
⊢ π ⁻¹' s ∈ 𝓝[t] a

tactic: replace hs : (fun x : t => π x) ⁻¹' s ∈ 𝓝 a := preimage_nhds_coinduced hs
state_before: case intro
α : Type u_2
β : Type u_1
γ : Type ?u.8061
δ : Type ?u.8064
inst✝ : TopologicalSpace α
π : α → β
s : Set β
t : Set α
a : { x // x ∈ t }
hs : s ∈ 𝓝 (π ↑a)
⊢ π ⁻¹' s ∈ 𝓝[t] ↑a

tactic: rwa [← map_nhds_subtype_val, mem_map]
state_before: case intro
α : Type u_2
β : Type u_1
γ : Type ?u.8061
δ : Type ?u.8064
inst✝ : TopologicalSpace α
π : α → β
s : Set β
t : Set α
a : { x // x ∈ t }
hs : (fun x => π ↑x) ⁻¹' s ∈ 𝓝 a
⊢ π ⁻¹' s ∈ 𝓝[t] ↑a
Theorem: continuous_uncurry_of_discreteTopology
File: Mathlib/Topology/Constructions.lean

tactic: apply continuous_iff_continuousAt.2
state_before: α : Type u
β : Type v
γ : Type u_1
δ : Type ?u.34136
ε : Type ?u.34139
ζ : Type ?u.34142
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : TopologicalSpace γ
inst✝³ : TopologicalSpace δ
inst✝² : TopologicalSpace ε
inst✝¹ : TopologicalSpace ζ
inst✝ : DiscreteTopology α
f : α → β → γ
hf : ∀ (a : α), Continuous (f a)
⊢ Continuous (uncurry f)

tactic: rintro ⟨a, x⟩
state_before: α : Type u
β : Type v
γ : Type u_1
δ : Type ?u.34136
ε : Type ?u.34139
ζ : Type ?u.34142
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : TopologicalSpace γ
inst✝³ : TopologicalSpace δ
inst✝² : TopologicalSpace ε
inst✝¹ : TopologicalSpace ζ
inst✝ : DiscreteTopology α
f : α → β → γ
hf : ∀ (a : α), Continuous (f a)
⊢ ∀ (x : α × β), ContinuousAt (uncurry f) x

tactic: change map _ _ ≤ _
state_before: case mk
α : Type u
β : Type v
γ : Type u_1
δ : Type ?u.34136
ε : Type ?u.34139
ζ : Type ?u.34142
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : TopologicalSpace γ
inst✝³ : TopologicalSpace δ
inst✝² : TopologicalSpace ε
inst✝¹ : TopologicalSpace ζ
inst✝ : DiscreteTopology α
f : α → β → γ
hf : ∀ (a : α), Continuous (f a)
a : α
x : β
⊢ ContinuousAt (uncurry f) (a, x)

tactic: rw [nhds_prod_eq, nhds_discrete, Filter.map_pure_prod]
state_before: case mk
α : Type u
β : Type v
γ : Type u_1
δ : Type ?u.34136
ε : Type ?u.34139
ζ : Type ?u.34142
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : TopologicalSpace γ
inst✝³ : TopologicalSpace δ
inst✝² : TopologicalSpace ε
inst✝¹ : TopologicalSpace ζ
inst✝ : DiscreteTopology α
f : α → β → γ
hf : ∀ (a : α), Continuous (f a)
a : α
x : β
⊢ map (uncurry f) (𝓝 (a, x)) ≤ 𝓝 (uncurry f (a, x))

tactic: exact (hf a).continuousAt
state_before: case mk
α : Type u
β : Type v
γ : Type u_1
δ : Type ?u.34136
ε : Type ?u.34139
ζ : Type ?u.34142
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : TopologicalSpace γ
inst✝³ : TopologicalSpace δ
inst✝² : TopologicalSpace ε
inst✝¹ : TopologicalSpace ζ
inst✝ : DiscreteTopology α
f : α → β → γ
hf : ∀ (a : α), Continuous (f a)
a : α
x : β
⊢ map (f a) (𝓝 x) ≤ 𝓝 (uncurry f (a, x))
Theorem: primorial_le_4_pow
File: Mathlib/NumberTheory/Primorial.lean

tactic: induction' n using Nat.strong_induction_on with n ihn
state_before: n : ℕ
⊢ n# ≤ 4 ^ n

tactic: cases' n with n
state_before: case h
n : ℕ
ihn : ∀ (m : ℕ), m < n → m# ≤ 4 ^ m
⊢ n# ≤ 4 ^ n

tactic: rcases n.even_or_odd with (⟨m, rfl⟩ | ho)
state_before: case h.succ
n : ℕ
ihn : ∀ (m : ℕ), m < succ n → m# ≤ 4 ^ m
⊢ succ n# ≤ 4 ^ succ n

tactic: rfl
state_before: case h.zero
ihn : ∀ (m : ℕ), m < zero → m# ≤ 4 ^ m
⊢ zero# ≤ 4 ^ zero

tactic: rcases m.eq_zero_or_pos with (rfl | hm)
state_before: case h.succ.inl.intro
m : ℕ
ihn : ∀ (m_1 : ℕ), m_1 < succ (m + m) → m_1# ≤ 4 ^ m_1
⊢ succ (m + m)# ≤ 4 ^ succ (m + m)

tactic: calc
  (m + m + 1)# = (m + 1 + m)# := by rw [add_right_comm]
  _ ≤ (m + 1)# * choose (m + 1 + m) (m + 1) := primorial_add_le m.le_succ
  _ = (m + 1)# * choose (2 * m + 1) m := by rw [choose_symm_add, two_mul, add_right_comm]
  _ ≤ 4 ^ (m + 1) * 4 ^ m :=
    mul_le_mul' (ihn _ <| succ_lt_succ <| (lt_add_iff_pos_left _).2 hm) (choose_middle_le_pow _)
  _ ≤ 4 ^ (m + m + 1) := by rw [← pow_add, add_right_comm]
state_before: case h.succ.inl.intro.inr
m : ℕ
ihn : ∀ (m_1 : ℕ), m_1 < succ (m + m) → m_1# ≤ 4 ^ m_1
hm : m > 0
⊢ succ (m + m)# ≤ 4 ^ succ (m + m)

tactic: decide
state_before: case h.succ.inl.intro.inl
ihn : ∀ (m : ℕ), m < succ (0 + 0) → m# ≤ 4 ^ m
⊢ succ (0 + 0)# ≤ 4 ^ succ (0 + 0)

tactic: rw [add_right_comm]
state_before: m : ℕ
ihn : ∀ (m_1 : ℕ), m_1 < succ (m + m) → m_1# ≤ 4 ^ m_1
hm : m > 0
⊢ (m + m + 1)# = (m + 1 + m)#

tactic: rw [choose_symm_add, two_mul, add_right_comm]
state_before: m : ℕ
ihn : ∀ (m_1 : ℕ), m_1 < succ (m + m) → m_1# ≤ 4 ^ m_1
hm : m > 0
⊢ (m + 1)# * Nat.choose (m + 1 + m) (m + 1) = (m + 1)# * Nat.choose (2 * m + 1) m

tactic: rw [← pow_add, add_right_comm]
state_before: m : ℕ
ihn : ∀ (m_1 : ℕ), m_1 < succ (m + m) → m_1# ≤ 4 ^ m_1
hm : m > 0
⊢ 4 ^ (m + 1) * 4 ^ m ≤ 4 ^ (m + m + 1)

tactic: rcases Decidable.eq_or_ne n 1 with (rfl | hn)
state_before: case h.succ.inr
n : ℕ
ihn : ∀ (m : ℕ), m < succ n → m# ≤ 4 ^ m
ho : Odd n
⊢ succ n# ≤ 4 ^ succ n

tactic: decide
state_before: case h.succ.inr.inl
ihn : ∀ (m : ℕ), m < succ 1 → m# ≤ 4 ^ m
ho : Odd 1
⊢ succ 1# ≤ 4 ^ succ 1

tactic: calc
  (n + 1)# = n# := primorial_succ hn ho
  _ ≤ 4 ^ n := ihn n n.lt_succ_self
  _ ≤ 4 ^ (n + 1) := pow_le_pow_of_le_right four_pos n.le_succ
state_before: case h.succ.inr.inr
n : ℕ
ihn : ∀ (m : ℕ), m < succ n → m# ≤ 4 ^ m
ho : Odd n
hn : n ≠ 1
⊢ succ n# ≤ 4 ^ succ n
Theorem: coprime_sq_sub_mul_of_odd_even
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: rw [Int.gcd, ← Int.natAbs_neg (m ^ 2 - n ^ 2)]
state_before: m n : ℤ
h : Int.gcd m n = 1
hm : m % 2 = 1
hn : n % 2 = 0
⊢ Int.gcd (m ^ 2 - n ^ 2) (2 * m * n) = 1

tactic: rw [(by ring : 2 * m * n = 2 * n * m), (by ring : -(m ^ 2 - n ^ 2) = n ^ 2 - m ^ 2)]
state_before: m n : ℤ
h : Int.gcd m n = 1
hm : m % 2 = 1
hn : n % 2 = 0
⊢ Nat.gcd (Int.natAbs (-(m ^ 2 - n ^ 2))) (Int.natAbs (2 * m * n)) = 1

tactic: apply coprime_sq_sub_mul_of_even_odd _ hn hm
state_before: m n : ℤ
h : Int.gcd m n = 1
hm : m % 2 = 1
hn : n % 2 = 0
⊢ Nat.gcd (Int.natAbs (n ^ 2 - m ^ 2)) (Int.natAbs (2 * n * m)) = 1

tactic: rwa [Int.gcd_comm]
state_before: m n : ℤ
h : Int.gcd m n = 1
hm : m % 2 = 1
hn : n % 2 = 0
⊢ Int.gcd n m = 1

tactic: ring
state_before: m n : ℤ
h : Int.gcd m n = 1
hm : m % 2 = 1
hn : n % 2 = 0
⊢ 2 * m * n = 2 * n * m

tactic: ring
state_before: m n : ℤ
h : Int.gcd m n = 1
hm : m % 2 = 1
hn : n % 2 = 0
⊢ -(m ^ 2 - n ^ 2) = n ^ 2 - m ^ 2
Theorem: PNat.Coprime.gcd_mul_right_cancel_right
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [mul_comm]
state_before: m n k : ℕ+
⊢ Coprime k m → gcd m (n * k) = gcd m n

tactic: apply Coprime.gcd_mul_left_cancel_right
state_before: m n k : ℕ+
⊢ Coprime k m → gcd m (k * n) = gcd m n
Theorem: Sylow.stabilizer_eq_normalizer
File: Mathlib/GroupTheory/Sylow.lean

tactic: ext
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
P : Sylow p G
⊢ stabilizer G P = normalizer ↑P

tactic: simp [Sylow.smul_eq_iff_mem_normalizer]
state_before: case h
p : ℕ
G : Type u_1
inst✝ : Group G
P : Sylow p G
x✝ : G
⊢ x✝ ∈ stabilizer G P ↔ x✝ ∈ normalizer ↑P
Theorem: Zsqrtd.sqLe_smul
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simpa [SqLe, mul_left_comm, mul_assoc] using Nat.mul_le_mul_left (n * n) xy
state_before: d✝ : ℤ
c d x y n : ℕ
xy : SqLe x c y d
⊢ SqLe (n * x) c (n * y) d
Theorem: Subgroup.commute_subtype_of_commute
File: Mathlib/GroupTheory/NoncommPiCoprod.lean

tactic: rintro ⟨x, hx⟩ ⟨y, hy⟩
state_before: G : Type u_2
inst✝ : Group G
ι : Type u_1
hdec : DecidableEq ι
hfin : Fintype ι
H : ι → Subgroup G
f g : (i : ι) → { x // x ∈ H i }
hcomm : ∀ (i j : ι), i ≠ j → ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y
i j : ι
hne : i ≠ j
⊢ ∀ (x : { x // x ∈ H i }) (y : { x // x ∈ H j }), Commute (↑(Subgroup.subtype (H i)) x) (↑(Subgroup.subtype (H j)) y)

tactic: exact hcomm i j hne x y hx hy
state_before: case mk.mk
G : Type u_2
inst✝ : Group G
ι : Type u_1
hdec : DecidableEq ι
hfin : Fintype ι
H : ι → Subgroup G
f g : (i : ι) → { x // x ∈ H i }
hcomm : ∀ (i j : ι), i ≠ j → ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y
i j : ι
hne : i ≠ j
x : G
hx : x ∈ H i
y : G
hy : y ∈ H j
⊢ Commute (↑(Subgroup.subtype (H i)) { val := x, property := hx })
    (↑(Subgroup.subtype (H j)) { val := y, property := hy })
Theorem: LinearMap.eq_adjoint_iff_basis_right
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: refine' ⟨fun h x y => by rw [h, adjoint_inner_left], fun h => _⟩
state_before: 𝕜 : Type u_2
E : Type u_4
F : Type u_3
G : Type ?u.2052027
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
ι : Type u_1
b : Basis ι 𝕜 F
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
⊢ A = ↑adjoint B ↔ ∀ (i : ι) (x : E), inner (↑A x) (↑b i) = inner x (↑B (↑b i))

tactic: ext x
state_before: 𝕜 : Type u_2
E : Type u_4
F : Type u_3
G : Type ?u.2052027
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
ι : Type u_1
b : Basis ι 𝕜 F
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (i : ι) (x : E), inner (↑A x) (↑b i) = inner x (↑B (↑b i))
⊢ A = ↑adjoint B

tactic: refine' ext_inner_right_basis b fun i => by simp only [h i, adjoint_inner_left]
state_before: case h
𝕜 : Type u_2
E : Type u_4
F : Type u_3
G : Type ?u.2052027
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
ι : Type u_1
b : Basis ι 𝕜 F
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (i : ι) (x : E), inner (↑A x) (↑b i) = inner x (↑B (↑b i))
x : E
⊢ ↑A x = ↑(↑adjoint B) x

tactic: rw [h, adjoint_inner_left]
state_before: 𝕜 : Type u_2
E : Type u_4
F : Type u_3
G : Type ?u.2052027
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
ι : Type u_1
b : Basis ι 𝕜 F
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : A = ↑adjoint B
x : ι
y : E
⊢ inner (↑A y) (↑b x) = inner y (↑B (↑b x))

tactic: simp only [h i, adjoint_inner_left]
state_before: 𝕜 : Type u_2
E : Type u_4
F : Type u_3
G : Type ?u.2052027
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
ι : Type u_1
b : Basis ι 𝕜 F
A : E →ₗ[𝕜] F
B : F →ₗ[𝕜] E
h : ∀ (i : ι) (x : E), inner (↑A x) (↑b i) = inner x (↑B (↑b i))
x : E
i : ι
⊢ inner (↑A x) (↑b i) = inner (↑(↑adjoint B) x) (↑b i)
Theorem: Set.zero_div_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: simp [subset_def, mem_div]
state_before: F : Type ?u.142624
α : Type u_1
β : Type ?u.142630
γ : Type ?u.142633
inst✝ : GroupWithZero α
s✝ t s : Set α
⊢ 0 / s ⊆ 0
Theorem: Cycle.chain_range_succ
File: Mathlib/Data/List/Cycle.lean

tactic: rw [range_succ, ← coe_cons_eq_coe_append, chain_coe_cons, ← range_succ, chain_range_succ]
state_before: α : Type ?u.317005
r : ℕ → ℕ → Prop
n : ℕ
⊢ Chain r ↑(range (Nat.succ n)) ↔ r n 0 ∧ ∀ (m : ℕ), m < n → r m (Nat.succ m)
Theorem: CircleDeg1Lift.iterate_pos_lt_iff
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simpa only [nsmul_eq_mul, add_right_iterate] using
  (f.commute_add_int m).iterate_pos_lt_iff_map_lt f.monotone (strictMono_id.add_const (m : ℝ)) hn
state_before: f g : CircleDeg1Lift
x : ℝ
m : ℤ
n : ℕ
hn : 0 < n
⊢ (↑f^[n]) x < x + ↑n * ↑m ↔ ↑f x < x + ↑m
Theorem: Ordinal.mem_closed_iff_sup
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: rw [← mem_closure_iff_sup, hs.closure_eq]
state_before: s : Set Ordinal
a : Ordinal
hs : IsClosed s
⊢ a ∈ s ↔ ∃ ι _hι f, (∀ (i : ι), f i ∈ s) ∧ sup f = a
Theorem: Set.bounded_lt_inter_le
File: Mathlib/Order/Bounded.lean

tactic: convert @bounded_lt_inter_not_lt _ s _ a
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Bounded (fun x x_1 => x < x_1) (s ∩ {b | a ≤ b}) ↔ Bounded (fun x x_1 => x < x_1) s

tactic: exact not_lt.symm
state_before: case h.e'_1.h.e'_3.h.e'_4.h.e'_2.h.a
α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a x✝ : α
⊢ a ≤ x✝ ↔ ¬x✝ < a
Theorem: Nat.gcd_mul_right_add_left
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [gcd_comm, gcd_mul_right_add_right, gcd_comm]
state_before: m n k : ℕ
⊢ gcd (k * n + m) n = gcd m n
Theorem: Finmap.lookup_insert_of_ne
File: Mathlib/Data/Finmap.lean

tactic: simp only [insert_toFinmap, lookup_toFinmap, lookup_insert_ne h]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
s✝ : Finmap β
h : a' ≠ a
s : AList β
⊢ lookup a' (insert a b ⟦s⟧) = lookup a' ⟦s⟧
Theorem: List.isSuffix.filter
File: Std/Data/List/Lemmas.lean

tactic: obtain ⟨xs, rfl⟩ := h
state_before: α : Type u_1
p : α → Bool
l₁ l₂ : List α
h : l₁ <:+ l₂
⊢ List.filter p l₁ <:+ List.filter p l₂

tactic: rw [filter_append]
state_before: case intro
α : Type u_1
p : α → Bool
l₁ xs : List α
⊢ List.filter p l₁ <:+ List.filter p (xs ++ l₁)

tactic: apply suffix_append
state_before: case intro
α : Type u_1
p : α → Bool
l₁ xs : List α
⊢ List.filter p l₁ <:+ List.filter p xs ++ List.filter p l₁
Theorem: List.cyclicPermutations_of_ne_nil
File: Mathlib/Data/List/Rotate.lean

tactic: obtain ⟨hd, tl, rfl⟩ := exists_cons_of_ne_nil h
state_before: α : Type u
l✝ l' l : List α
h : l ≠ []
⊢ cyclicPermutations l = dropLast (zipWith (fun x x_1 => x ++ x_1) (tails l) (inits l))

tactic: exact cyclicPermutations_cons _ _
state_before: case intro.intro
α : Type u
l l' : List α
hd : α
tl : List α
h : hd :: tl ≠ []
⊢ cyclicPermutations (hd :: tl) = dropLast (zipWith (fun x x_1 => x ++ x_1) (tails (hd :: tl)) (inits (hd :: tl)))
Theorem: exists_signed_sum_aux
File: Mathlib/Data/Sign.lean

tactic: refine'
  ⟨(Σ _ : { x // x ∈ s }, ℕ), Finset.univ.sigma fun a => range (f a).natAbs,
    fun a => sign (f a.1), fun a => a.1, fun a => a.1.2, _, _⟩
state_before: α✝ : Type ?u.131858
α : Type u_1
inst✝ : DecidableEq α
s : Finset α
f : α → ℤ
⊢ ∃ β t sgn g,
    (∀ (b : β), g b ∈ s) ∧
      card t = ∑ a in s, Int.natAbs (f a) ∧ ∀ (a : α), a ∈ s → (∑ b in t, if g b = a then ↑(sgn b) else 0) = f a

tactic: simp [sum_attach (f := fun a => (f a).natAbs)]
state_before: case refine'_1
α✝ : Type ?u.131858
α : Type u_1
inst✝ : DecidableEq α
s : Finset α
f : α → ℤ
⊢ card (Finset.sigma univ fun a => range (Int.natAbs (f ↑a))) = ∑ a in s, Int.natAbs (f a)

tactic: intro x hx
state_before: case refine'_2
α✝ : Type ?u.131858
α : Type u_1
inst✝ : DecidableEq α
s : Finset α
f : α → ℤ
⊢ ∀ (a : α),
    a ∈ s →
      (∑ b in Finset.sigma univ fun a => range (Int.natAbs (f ↑a)),
          if (fun a => ↑a.fst) b = a then ↑((fun a => ↑sign (f ↑a.fst)) b) else 0) =
        f a

tactic: simp [sum_sigma, hx, ← Int.sign_eq_sign, Int.sign_mul_abs, mul_comm (|f _|),
  sum_attach (s := s) (f := fun y => if y = x then f y else 0)]
state_before: case refine'_2
α✝ : Type ?u.131858
α : Type u_1
inst✝ : DecidableEq α
s : Finset α
f : α → ℤ
x : α
hx : x ∈ s
⊢ (∑ b in Finset.sigma univ fun a => range (Int.natAbs (f ↑a)),
      if (fun a => ↑a.fst) b = x then ↑((fun a => ↑sign (f ↑a.fst)) b) else 0) =
    f x
Theorem: Complex.isTheta_cpow_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: simp only [ofReal_one, div_one]
state_before: α : Type u_1
l : Filter α
f g : α → ℂ
hl_im : IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => Abs.abs (g x).im
hl : ∀ᶠ (x : α) in l, f x = 0 → (g x).re = 0 → g x = 0
⊢ (let_fun this := fun x => ↑abs (f x) ^ (g x).re / 1;
    this) =ᶠ[l]
    let_fun this := fun x => ↑abs (f x) ^ (g x).re;
    this

tactic: rfl
state_before: α : Type u_1
l : Filter α
f g : α → ℂ
hl_im : IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => Abs.abs (g x).im
hl : ∀ᶠ (x : α) in l, f x = 0 → (g x).re = 0 → g x = 0
⊢ (fun x => ↑abs (f x) ^ (g x).re) =ᶠ[l] fun x => ↑abs (f x) ^ (g x).re
Theorem: Real.hasStrictDerivAt_arsinh
File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

tactic: convert sinhHomeomorph.toLocalHomeomorph.hasStrictDerivAt_symm (mem_univ x) (cosh_pos _).ne'
  (hasStrictDerivAt_sinh _) using 2
state_before: x✝ y x : ℝ
⊢ HasStrictDerivAt arsinh (sqrt (1 + x ^ 2))⁻¹ x

tactic: exact (cosh_arsinh _).symm
state_before: case h.e'_7.h.e'_3
x✝ y x : ℝ
⊢ sqrt (1 + x ^ 2) = cosh (↑(LocalHomeomorph.symm (Homeomorph.toLocalHomeomorph sinhHomeomorph)) x)
Theorem: ENNReal.toNNReal_strict_mono
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa [← ENNReal.coe_lt_coe, hb, h.ne_top]
state_before: α : Type ?u.799785
β : Type ?u.799788
a b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
h : a < b
⊢ ENNReal.toNNReal a < ENNReal.toNNReal b