1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Polynomial.Chebyshev.T_eq_X_mul_T_sub_pol_U
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: have h₁ := U_eq_X_mul_U_add_T R n
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
⊢ T R (n + 2) = X * T R (n + 1) - (1 - X ^ 2) * U R n
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
h₁ : U R (n + 1) = X * U R n + T R (n + 1)
⊢ T R (n + 2) = X * T R (n + 1) - (1 - X ^ 2) * U R n

tactic: have h₂ := U_eq_X_mul_U_add_T R (n + 1)
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
h₁ : U R (n + 1) = X * U R n + T R (n + 1)
⊢ T R (n + 2) = X * T R (n + 1) - (1 - X ^ 2) * U R n
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
h₁ : U R (n + 1) = X * U R n + T R (n + 1)
h₂ : U R (n + 1 + 1) = X * U R (n + 1) + T R (n + 1 + 1)
⊢ T R (n + 2) = X * T R (n + 1) - (1 - X ^ 2) * U R n

tactic: have h₃ := U_add_two R n
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
h₁ : U R (n + 1) = X * U R n + T R (n + 1)
h₂ : U R (n + 1 + 1) = X * U R (n + 1) + T R (n + 1 + 1)
⊢ T R (n + 2) = X * T R (n + 1) - (1 - X ^ 2) * U R n
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
h₁ : U R (n + 1) = X * U R n + T R (n + 1)
h₂ : U R (n + 1 + 1) = X * U R (n + 1) + T R (n + 1 + 1)
h₃ : U R (n + 2) = 2 * X * U R (n + 1) - U R n
⊢ T R (n + 2) = X * T R (n + 1) - (1 - X ^ 2) * U R n

tactic: linear_combination (norm := ring_nf) h₃ - h₂ + (X:R[X]) * h₁
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
h₁ : U R (n + 1) = X * U R n + T R (n + 1)
h₂ : U R (n + 1 + 1) = X * U R (n + 1) + T R (n + 1 + 1)
h₃ : U R (n + 2) = 2 * X * U R (n + 1) - U R n
⊢ T R (n + 2) = X * T R (n + 1) - (1 - X ^ 2) * U R n
state_after: no goals
Theorem: inv_lt_self_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: simp [inv_lt_iff_one_lt_mul]
state_before: α : Type u
inst✝ : LinearOrderedCommGroup α
a b c : α
⊢ a⁻¹ < a ↔ 1 < a
state_after: no goals
Theorem: ContinuousLinearMap.iSup_rayleigh_eq_iSup_rayleigh_sphere
File: Mathlib/Analysis/InnerProductSpace/Rayleigh.lean

tactic: simp only [← @sSup_image' _ _ _ _ (rayleighQuotient T),
  T.image_rayleigh_eq_image_rayleigh_sphere hr]
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →L[𝕜] E
r : ℝ
hr : 0 < r
⊢ ⨆ x, T.rayleighQuotient ↑x = ⨆ x, T.rayleighQuotient ↑x
state_after: no goals
Theorem: Finsupp.coe_update
File: Mathlib/Data/Finsupp/Defs.lean

tactic: delta update Function.update
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ ⇑(f.update a b) = Function.update (⇑f) a b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ ⇑{ support := if b = 0 then f.support.erase a else insert a f.support,
        toFun := fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1, mem_support_toFun := ⋯ } =
    fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ ⇑{ support := if b = 0 then f.support.erase a else insert a f.support,
        toFun := fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1, mem_support_toFun := ⋯ } =
    fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
x✝ : α
⊢ { support := if b = 0 then f.support.erase a else insert a f.support,
        toFun := fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1, mem_support_toFun := ⋯ }
      x✝ =
    if h : x✝ = a then ⋯ ▸ b else f x✝

tactic: dsimp
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
x✝ : α
⊢ { support := if b = 0 then f.support.erase a else insert a f.support,
        toFun := fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1, mem_support_toFun := ⋯ }
      x✝ =
    if h : x✝ = a then ⋯ ▸ b else f x✝
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
x✝ : α
⊢ (if h : x✝ = a then ⋯ ▸ b else f x✝) = if h : x✝ = a then ⋯ ▸ b else f x✝

tactic: split_ifs <;> simp
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
x✝ : α
⊢ (if h : x✝ = a then ⋯ ▸ b else f x✝) = if h : x✝ = a then ⋯ ▸ b else f x✝
state_after: no goals
Theorem: Matrix.zpow_neg_mul_zpow_self
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [zpow_neg h, nonsing_inv_mul _ (h.det_zpow _)]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
n : ℤ
A : M
h : IsUnit A.det
⊢ A ^ (-n) * A ^ n = 1
state_after: no goals
Theorem: PrimeMultiset.prod_sup
File: Mathlib/Data/PNat/Factors.lean

tactic: let n := u.prod
state_before: u v : PrimeMultiset
⊢ (u ⊔ v).prod = u.prod.lcm v.prod
state_after: u v : PrimeMultiset
n : ℕ+ := u.prod
⊢ (u ⊔ v).prod = u.prod.lcm v.prod

tactic: let m := v.prod
state_before: u v : PrimeMultiset
n : ℕ+ := u.prod
⊢ (u ⊔ v).prod = u.prod.lcm v.prod
state_after: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
⊢ (u ⊔ v).prod = u.prod.lcm v.prod

tactic: change (u ⊔ v).prod = PNat.lcm n m
state_before: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
⊢ (u ⊔ v).prod = u.prod.lcm v.prod
state_after: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
⊢ (u ⊔ v).prod = n.lcm m

tactic: have : u = n.factorMultiset := u.factorMultiset_prod.symm
state_before: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
⊢ (u ⊔ v).prod = n.lcm m
state_after: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
this : u = n.factorMultiset
⊢ (u ⊔ v).prod = n.lcm m

tactic: rw [this]
state_before: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
this : u = n.factorMultiset
⊢ (u ⊔ v).prod = n.lcm m
state_after: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
this : u = n.factorMultiset
⊢ (n.factorMultiset ⊔ v).prod = n.lcm m

tactic: have : v = m.factorMultiset := v.factorMultiset_prod.symm
state_before: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
this : u = n.factorMultiset
⊢ (n.factorMultiset ⊔ v).prod = n.lcm m
state_after: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
this✝ : u = n.factorMultiset
this : v = m.factorMultiset
⊢ (n.factorMultiset ⊔ v).prod = n.lcm m

tactic: rw [this]
state_before: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
this✝ : u = n.factorMultiset
this : v = m.factorMultiset
⊢ (n.factorMultiset ⊔ v).prod = n.lcm m
state_after: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
this✝ : u = n.factorMultiset
this : v = m.factorMultiset
⊢ (n.factorMultiset ⊔ m.factorMultiset).prod = n.lcm m

tactic: rw [← PNat.factorMultiset_lcm n m, PNat.prod_factorMultiset]
state_before: u v : PrimeMultiset
n : ℕ+ := u.prod
m : ℕ+ := v.prod
this✝ : u = n.factorMultiset
this : v = m.factorMultiset
⊢ (n.factorMultiset ⊔ m.factorMultiset).prod = n.lcm m
state_after: no goals
Theorem: WeierstrassCurve.coeff_preΨ'_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

tactic: rcases n.even_or_odd' with ⟨n, rfl | rfl⟩
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
h : ↑n ≠ 0
⊢ (W.preΨ' n).coeff ((n ^ 2 - if Even n then 4 else 1) / 2) ≠ 0
state_after: case intro.inl
R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
h : ↑(2 * n) ≠ 0
⊢ (W.preΨ' (2 * n)).coeff (((2 * n) ^ 2 - if Even (2 * n) then 4 else 1) / 2) ≠ 0

case intro.inr
R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
h : ↑(2 * n + 1) ≠ 0
⊢ (W.preΨ' (2 * n + 1)).coeff (((2 * n + 1) ^ 2 - if Even (2 * n + 1) then 4 else 1) / 2) ≠ 0

tactic: rw [coeff_preΨ', if_pos <| even_two_mul n, n.mul_div_cancel_left two_pos]
state_before: case intro.inl
R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
h : ↑(2 * n) ≠ 0
⊢ (W.preΨ' (2 * n)).coeff (((2 * n) ^ 2 - if Even (2 * n) then 4 else 1) / 2) ≠ 0
state_after: case intro.inl
R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
h : ↑(2 * n) ≠ 0
⊢ ↑n ≠ 0

tactic: exact right_ne_zero_of_mul <| by rwa [← Nat.cast_mul]
state_before: case intro.inl
R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
h : ↑(2 * n) ≠ 0
⊢ ↑n ≠ 0
state_after: no goals

tactic: rwa [← Nat.cast_mul]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
h : ↑(2 * n) ≠ 0
⊢ ?m.109549 * ↑n ≠ 0
state_after: no goals

tactic: rwa [coeff_preΨ', if_neg n.not_even_two_mul_add_one]
state_before: case intro.inr
R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
h : ↑(2 * n + 1) ≠ 0
⊢ (W.preΨ' (2 * n + 1)).coeff (((2 * n + 1) ^ 2 - if Even (2 * n + 1) then 4 else 1) / 2) ≠ 0
state_after: no goals
Theorem: Nat.div2_bit
File: Mathlib/Data/Nat/Bits.lean

tactic: rw [bit_val, div2_val, Nat.add_comm, add_mul_div_left, div_eq_of_lt, Nat.zero_add]
<;> cases b
<;> decide
state_before: m n✝ : ℕ
b : Bool
n : ℕ
⊢ (bit b n).div2 = n
state_after: no goals
Theorem: Ordinal.opow_limit
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: simp only [opow_def, if_neg a0]
state_before: a b : Ordinal.{u}
a0 : a ≠ 0
h : b.IsLimit
⊢ a ^ b = b.bsup fun c x => a ^ c
state_after: a b : Ordinal.{u}
a0 : a ≠ 0
h : b.IsLimit
⊢ (b.limitRecOn 1 (fun x IH => IH * a) fun b x => b.bsup) =
    b.bsup fun c x => c.limitRecOn 1 (fun x IH => IH * a) fun b x => b.bsup

tactic: rw [limitRecOn_limit _ _ _ _ h]
state_before: a b : Ordinal.{u}
a0 : a ≠ 0
h : b.IsLimit
⊢ (b.limitRecOn 1 (fun x IH => IH * a) fun b x => b.bsup) =
    b.bsup fun c x => c.limitRecOn 1 (fun x IH => IH * a) fun b x => b.bsup
state_after: no goals
Theorem: Finset.image_image₂_antidistrib_right
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
g : γ → δ
f' : β → α' → δ
g' : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
⊢ ↑(image g (image₂ f s t)) = ↑(image₂ f' t (image g' s))
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
g : γ → δ
f' : β → α' → δ
g' : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
⊢ g '' image2 f ↑s ↑t = image2 f' (↑t) (g' '' ↑s)

tactic: exact image_image2_antidistrib_right h_antidistrib
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
g : γ → δ
f' : β → α' → δ
g' : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
⊢ g '' image2 f ↑s ↑t = image2 f' (↑t) (g' '' ↑s)
state_after: no goals
Theorem: Batteries.RBNode.Ordered.map
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: refine ⟨ax.map ?_, xb.map ?_, ha.map f, hb.map f⟩ <;> exact IsMonotone.lt_mono
state_before: α : Type u_1
β : Type u_2
cmpα : α → α → Ordering
cmpβ : β → β → Ordering
f : α → β
inst✝ : IsMonotone cmpα cmpβ f
c✝ : RBColor
a : RBNode α
x : α
b : RBNode α
ax : All (fun x_1 => cmpLT cmpα x_1 x) a
xb : All (fun x_1 => cmpLT cmpα x x_1) b
ha : Ordered cmpα a
hb : Ordered cmpα b
⊢ Ordered cmpβ (map f (node c✝ a x b))
state_after: no goals
Theorem: MulEquiv.prime_iff
File: Mathlib/Algebra/Associated.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : CommMonoidWithZero α
inst✝⁴ : CommMonoidWithZero β
F : Type u_5
G : Type u_6
inst✝³ : FunLike F α β
inst✝² : MonoidWithZeroHomClass F α β
inst✝¹ : FunLike G β α
inst✝ : MulHomClass G β α
f : F
g : G
p : α
e : α ≃* β
h : Prime p
a : β
⊢ e (e.symm a) = a
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : CommMonoidWithZero α
inst✝⁴ : CommMonoidWithZero β
F : Type u_5
G : Type u_6
inst✝³ : FunLike F α β
inst✝² : MonoidWithZeroHomClass F α β
inst✝¹ : FunLike G β α
inst✝ : MulHomClass G β α
f : F
g : G
p : α
e : α ≃* β
a : α
⊢ e.symm (e a) = a
state_after: no goals
Theorem: MeasureTheory.toReal_setLaverage
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: simpa [laverage_eq] using toReal_laverage hf hf'
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s t : Set α
f : α → ℝ≥0∞
hf : AEMeasurable f (μ.restrict s)
hf' : ∀ᵐ (x : α) ∂μ.restrict s, f x ≠ ⊤
⊢ (⨍⁻ (x : α) in s, f x ∂μ).toReal = ⨍ (x : α) in s, (f x).toReal ∂μ
state_after: no goals
Theorem: NNReal.coe_iSup
File: Mathlib/Data/NNReal/Basic.lean

tactic: rw [iSup, iSup, coe_sSup, ← Set.range_comp]
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
ι : Sort u_1
s : ι → ℝ≥0
⊢ ↑(⨆ i, s i) = ⨆ i, ↑(s i)
state_after: r r₁ r₂ : ℝ≥0
x y : ℝ
ι : Sort u_1
s : ι → ℝ≥0
⊢ sSup (Set.range (toReal ∘ fun i => s i)) = sSup (Set.range fun i => ↑(s i))

tactic: rfl
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
ι : Sort u_1
s : ι → ℝ≥0
⊢ sSup (Set.range (toReal ∘ fun i => s i)) = sSup (Set.range fun i => ↑(s i))
state_after: no goals
Theorem: WittVector.ghostComponent_frobeniusFun
File: Mathlib/RingTheory/WittVector/Frobenius.lean

tactic: simp only [ghostComponent_apply, frobeniusFun, coeff_mk, ← bind₁_frobeniusPoly_wittPolynomial,
  aeval_bind₁]
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
x : 𝕎 R
⊢ (ghostComponent n) x.frobeniusFun = (ghostComponent (n + 1)) x
state_after: no goals
Theorem: Set.uIcc_of_le
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: rw [uIcc, inf_eq_left.2 h, sup_eq_right.2 h]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Lattice α
inst✝ : Lattice β
a a₁ a₂ b b₁ b₂ c x : α
h : a ≤ b
⊢ [[a, b]] = Icc a b
state_after: no goals
Theorem: CategoryTheory.StructuredArrow.projectSubobject_factors
File: Mathlib/CategoryTheory/Subobject/Comma.lean

tactic: dsimp
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
⊢ (P.hom ≫ T.map (Subobject.underlyingIso (MonoOver.mk' f).arrow.right).inv) ≫
      T.map (projectSubobject (Subobject.mk f)).arrow =
    A.hom
state_after: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
⊢ (P.hom ≫ T.map (Subobject.underlyingIso f.right).inv) ≫ T.map (Subobject.mk f.right).arrow = A.hom

tactic: simp [← T.map_comp]
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
⊢ (P.hom ≫ T.map (Subobject.underlyingIso f.right).inv) ≫ T.map (Subobject.mk f.right).arrow = A.hom
state_after: no goals
Theorem: Finset.exists_le_sum_fiber_of_sum_fiber_nonpos_of_nsmul_le_sum
File: Mathlib/Combinatorics/Pigeonhole.lean

tactic: simpa
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCancelAddCommMonoid M
hf : ∀ y ∉ t, ∑ x ∈ filter (fun x => f x = y) s, w x ≤ 0
ht : t.Nonempty
hb : t.card • b ≤ ∑ x ∈ s, w x
⊢ ∑ _y ∈ t, b ≤ ∑ x ∈ s, w x
state_after: no goals
Theorem: Configuration.ProjectivePlane.lineCount_eq
File: Mathlib/Combinatorics/Configuration.lean

tactic: classical
  obtain ⟨q, -, -, l, -, -, -, -, h, -⟩ := Classical.choose_spec (@exists_config P L _ _)
  cases nonempty_fintype { l : L // q ∈ l }
  rw [order, lineCount_eq_lineCount L p q, lineCount_eq_lineCount L (Classical.choose _) q,
    lineCount, Nat.card_eq_fintype_card, Nat.sub_add_cancel]
  exact Fintype.card_pos_iff.mpr ⟨⟨l, h⟩⟩
state_before: P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p : P
⊢ lineCount L p = order P L + 1
state_after: no goals

tactic: obtain ⟨q, -, -, l, -, -, -, -, h, -⟩ := Classical.choose_spec (@exists_config P L _ _)
state_before: P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p : P
⊢ lineCount L p = order P L + 1
state_after: case intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p q : P
l : L
h : q ∈ l
⊢ lineCount L p = order P L + 1

tactic: cases nonempty_fintype { l : L // q ∈ l }
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p q : P
l : L
h : q ∈ l
⊢ lineCount L p = order P L + 1
state_after: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p q : P
l : L
h : q ∈ l
val✝ : Fintype { l // q ∈ l }
⊢ lineCount L p = order P L + 1

tactic: rw [order, lineCount_eq_lineCount L p q, lineCount_eq_lineCount L (Classical.choose _) q,
  lineCount, Nat.card_eq_fintype_card, Nat.sub_add_cancel]
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p q : P
l : L
h : q ∈ l
val✝ : Fintype { l // q ∈ l }
⊢ lineCount L p = order P L + 1
state_after: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p q : P
l : L
h : q ∈ l
val✝ : Fintype { l // q ∈ l }
⊢ 1 ≤ Fintype.card { l // q ∈ l }

tactic: exact Fintype.card_pos_iff.mpr ⟨⟨l, h⟩⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
p q : P
l : L
h : q ∈ l
val✝ : Fintype { l // q ∈ l }
⊢ 1 ≤ Fintype.card { l // q ∈ l }
state_after: no goals
Theorem: Inducing.of_comp_iff
File: Mathlib/Topology/Maps.lean

tactic: refine ⟨fun h ↦ ?_, hg.comp⟩
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hg : Inducing g
⊢ Inducing (g ∘ f) ↔ Inducing f
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hg : Inducing g
h : Inducing (g ∘ f)
⊢ Inducing f

tactic: rw [inducing_iff, hg.induced, induced_compose, h.induced]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hg : Inducing g
h : Inducing (g ∘ f)
⊢ Inducing f
state_after: no goals
Theorem: ContinuousLinearMap.comp_analyticOn
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: rintro x hx
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g✝ : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
s : Set E
g : F →L[𝕜] G
h : AnalyticOn 𝕜 f s
⊢ AnalyticOn 𝕜 (⇑g ∘ f) s
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g✝ : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x✝ : E
r r' : ℝ≥0∞
s : Set E
g : F →L[𝕜] G
h : AnalyticOn 𝕜 f s
x : E
hx : x ∈ s
⊢ AnalyticAt 𝕜 (⇑g ∘ f) x

tactic: rcases h x hx with ⟨p, r, hp⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g✝ : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x✝ : E
r r' : ℝ≥0∞
s : Set E
g : F →L[𝕜] G
h : AnalyticOn 𝕜 f s
x : E
hx : x ∈ s
⊢ AnalyticAt 𝕜 (⇑g ∘ f) x
state_after: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g✝ : E → F
p✝ pf pg : FormalMultilinearSeries 𝕜 E F
x✝ : E
r✝ r' : ℝ≥0∞
s : Set E
g : F →L[𝕜] G
h : AnalyticOn 𝕜 f s
x : E
hx : x ∈ s
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0∞
hp : HasFPowerSeriesOnBall f p x r
⊢ AnalyticAt 𝕜 (⇑g ∘ f) x

tactic: exact ⟨g.compFormalMultilinearSeries p, r, g.comp_hasFPowerSeriesOnBall hp⟩
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g✝ : E → F
p✝ pf pg : FormalMultilinearSeries 𝕜 E F
x✝ : E
r✝ r' : ℝ≥0∞
s : Set E
g : F →L[𝕜] G
h : AnalyticOn 𝕜 f s
x : E
hx : x ∈ s
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0∞
hp : HasFPowerSeriesOnBall f p x r
⊢ AnalyticAt 𝕜 (⇑g ∘ f) x
state_after: no goals