1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIso_inv_snd_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta pullbackDiagonalMapIso
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (pullbackDiagonalMapIso f i i₁ i₂).inv ≫ snd ≫ snd = snd
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ { hom := lift (snd ≫ fst) (snd ≫ snd) ⋯,
          inv := lift (fst ≫ i₁ ≫ fst) (map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd ⋯ ⋯) ⋯, hom_inv_id := ⋯,
          inv_hom_id := ⋯ }.inv ≫
      snd ≫ snd =
    snd

tactic: simp
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ { hom := lift (snd ≫ fst) (snd ≫ snd) ⋯,
          inv := lift (fst ≫ i₁ ≫ fst) (map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd ⋯ ⋯) ⋯, hom_inv_id := ⋯,
          inv_hom_id := ⋯ }.inv ≫
      snd ≫ snd =
    snd
state_after: no goals
Theorem: Matrix.dotProduct_stdBasis_eq_mul
File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

tactic: rw [dotProduct, Finset.sum_eq_single i, LinearMap.stdBasis_same]
state_before: m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝² : Semiring R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
v : n → R
c : R
i : n
⊢ v ⬝ᵥ (LinearMap.stdBasis R (fun x => R) i) c = v i * c
state_after: case h₀
m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝² : Semiring R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
v : n → R
c : R
i : n
⊢ ∀ b ∈ Finset.univ, b ≠ i → v b * (LinearMap.stdBasis R (fun x => R) i) c b = 0

case h₁
m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝² : Semiring R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
v : n → R
c : R
i : n
⊢ i ∉ Finset.univ → v i * (LinearMap.stdBasis R (fun x => R) i) c i = 0

tactic: exact fun _ _ hb => by rw [LinearMap.stdBasis_ne _ _ _ _ hb, mul_zero]
state_before: case h₀
m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝² : Semiring R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
v : n → R
c : R
i : n
⊢ ∀ b ∈ Finset.univ, b ≠ i → v b * (LinearMap.stdBasis R (fun x => R) i) c b = 0
state_after: no goals

tactic: rw [LinearMap.stdBasis_ne _ _ _ _ hb, mul_zero]
state_before: m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝² : Semiring R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
v : n → R
c : R
i x✝¹ : n
x✝ : x✝¹ ∈ Finset.univ
hb : x✝¹ ≠ i
⊢ v x✝¹ * (LinearMap.stdBasis R (fun x => R) i) c x✝¹ = 0
state_after: no goals

tactic: exact fun hi => False.elim (hi <| Finset.mem_univ _)
state_before: case h₁
m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝² : Semiring R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
v : n → R
c : R
i : n
⊢ i ∉ Finset.univ → v i * (LinearMap.stdBasis R (fun x => R) i) c i = 0
state_after: no goals
Theorem: CategoryTheory.Limits.Types.colimit_sound
File: Mathlib/CategoryTheory/Limits/Types.lean

tactic: rw [← w, Colimit.w_apply]
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j j' : J
x : F.obj j
x' : F.obj j'
f : j ⟶ j'
w : F.map f x = x'
⊢ colimit.ι F j x = colimit.ι F j' x'
state_after: no goals
Theorem: HasFiniteFPowerSeriesOnBall.sub
File: Mathlib/Analysis/Analytic/CPolynomial.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
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∞
n m : ℕ
hf : HasFiniteFPowerSeriesOnBall f pf x n r
hg : HasFiniteFPowerSeriesOnBall g pg x m r
⊢ HasFiniteFPowerSeriesOnBall (f - g) (pf - pg) x (max n m) r
state_after: no goals
Theorem: Nat.sInf_le
File: Mathlib/Data/Nat/Lattice.lean

tactic: rw [Nat.sInf_def ⟨m, hm⟩]
state_before: s : Set ℕ
m : ℕ
hm : m ∈ s
⊢ sInf s ≤ m
state_after: s : Set ℕ
m : ℕ
hm : m ∈ s
⊢ Nat.find ⋯ ≤ m

tactic: exact Nat.find_min' ⟨m, hm⟩ hm
state_before: s : Set ℕ
m : ℕ
hm : m ∈ s
⊢ Nat.find ⋯ ≤ m
state_after: no goals
Theorem: ite_and
File: Mathlib/Logic/Basic.lean

tactic: by_cases hp : P <;> by_cases hq : Q <;> simp [hp, hq]
state_before: α : Sort u_1
σ : α → Sort u_2
P Q R : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ (if P ∧ Q then a else b) = if P then if Q then a else b else b
state_after: no goals
Theorem: Set.image2_curry
File: Mathlib/Data/Set/NAry.lean

tactic: simp [← image_uncurry_prod, uncurry]
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
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Set α
t✝ t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α × β → γ
s : Set α
t : Set β
⊢ image2 (fun a b => f (a, b)) s t = f '' s ×ˢ t
state_after: no goals
Theorem: Asymptotics.IsLittleO.rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: refine .of_isBigOWith fun c hc ↦ ?_
state_before: α : Type u_1
r c : ℝ
l : Filter α
f g : α → ℝ
hr : 0 < r
hg : 0 ≤ᶠ[l] g
h : f =o[l] g
⊢ (fun x => f x ^ r) =o[l] fun x => g x ^ r
state_after: α : Type u_1
r c✝ : ℝ
l : Filter α
f g : α → ℝ
hr : 0 < r
hg : 0 ≤ᶠ[l] g
h : f =o[l] g
c : ℝ
hc : 0 < c
⊢ IsBigOWith c l (fun x => f x ^ r) fun x => g x ^ r

tactic: rw [← rpow_inv_rpow hc.le hr.ne']
state_before: α : Type u_1
r c✝ : ℝ
l : Filter α
f g : α → ℝ
hr : 0 < r
hg : 0 ≤ᶠ[l] g
h : f =o[l] g
c : ℝ
hc : 0 < c
⊢ IsBigOWith c l (fun x => f x ^ r) fun x => g x ^ r
state_after: α : Type u_1
r c✝ : ℝ
l : Filter α
f g : α → ℝ
hr : 0 < r
hg : 0 ≤ᶠ[l] g
h : f =o[l] g
c : ℝ
hc : 0 < c
⊢ IsBigOWith ((c ^ r⁻¹) ^ r) l (fun x => f x ^ r) fun x => g x ^ r

tactic: refine (h.forall_isBigOWith ?_).rpow ?_ ?_ hg <;> positivity
state_before: α : Type u_1
r c✝ : ℝ
l : Filter α
f g : α → ℝ
hr : 0 < r
hg : 0 ≤ᶠ[l] g
h : f =o[l] g
c : ℝ
hc : 0 < c
⊢ IsBigOWith ((c ^ r⁻¹) ^ r) l (fun x => f x ^ r) fun x => g x ^ r
state_after: no goals
Theorem: CochainComplex.HomComplex.δ_zero_cochain_comp
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: rw [add_comm, h₂]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₂ : ℤ
z₁ : Cochain F G 0
z₂ : Cochain G K n₂
m₂ : ℤ
h₂ : n₂ + 1 = m₂
⊢ 1 + n₂ = m₂
state_after: no goals
Theorem: UniformCauchySeqOn.uniformCauchySeqOnFilter
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rwa [← uniformCauchySeqOn_iff_uniformCauchySeqOnFilter]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
hF : UniformCauchySeqOn F p s
⊢ UniformCauchySeqOnFilter F p (𝓟 s)
state_after: no goals
Theorem: Rel.edgeDensity_nonneg
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: apply div_nonneg <;> exact mod_cast Nat.zero_le _
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t : Finset β
⊢ 0 ≤ edgeDensity r s t
state_after: no goals
Theorem: Finset.coe_singleton
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a✝ b a : α
⊢ ↑{a} = {a}
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a✝ b a x✝ : α
⊢ x✝ ∈ ↑{a} ↔ x✝ ∈ {a}

tactic: simp
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a✝ b a x✝ : α
⊢ x✝ ∈ ↑{a} ↔ x✝ ∈ {a}
state_after: no goals
Theorem: QuadraticForm.map_add_add_add_map
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: obtain ⟨B, h⟩ := Q.exists_companion
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x y z : M
⊢ Q (x + y + z) + (Q x + Q y + Q z) = Q (x + y) + Q (y + z) + Q (z + x)
state_after: case intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x y z : M
B : BilinForm R M
h : ∀ (x y : M), Q (x + y) = Q x + Q y + (B x) y
⊢ Q (x + y + z) + (Q x + Q y + Q z) = Q (x + y) + Q (y + z) + Q (z + x)

tactic: rw [add_comm z x]
state_before: case intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x y z : M
B : BilinForm R M
h : ∀ (x y : M), Q (x + y) = Q x + Q y + (B x) y
⊢ Q (x + y + z) + (Q x + Q y + Q z) = Q (x + y) + Q (y + z) + Q (z + x)
state_after: case intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x y z : M
B : BilinForm R M
h : ∀ (x y : M), Q (x + y) = Q x + Q y + (B x) y
⊢ Q (x + y + z) + (Q x + Q y + Q z) = Q (x + y) + Q (y + z) + Q (x + z)

tactic: simp only [h, map_add, LinearMap.add_apply]
state_before: case intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x y z : M
B : BilinForm R M
h : ∀ (x y : M), Q (x + y) = Q x + Q y + (B x) y
⊢ Q (x + y + z) + (Q x + Q y + Q z) = Q (x + y) + Q (y + z) + Q (x + z)
state_after: case intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x y z : M
B : BilinForm R M
h : ∀ (x y : M), Q (x + y) = Q x + Q y + (B x) y
⊢ Q x + Q y + (B x) y + Q z + ((B x) z + (B y) z) + (Q x + Q y + Q z) =
    Q x + Q y + (B x) y + (Q y + Q z + (B y) z) + (Q x + Q z + (B x) z)

tactic: abel
state_before: case intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x y z : M
B : BilinForm R M
h : ∀ (x y : M), Q (x + y) = Q x + Q y + (B x) y
⊢ Q x + Q y + (B x) y + Q z + ((B x) z + (B y) z) + (Q x + Q y + Q z) =
    Q x + Q y + (B x) y + (Q y + Q z + (B y) z) + (Q x + Q z + (B x) z)
state_after: no goals
Theorem: Primrec.map_decode_iff
File: Mathlib/Computability/Primrec.lean

tactic: simp only [Option.map_eq_bind]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → β → σ
⊢ (Primrec₂ fun a n => Option.map (f a) (decode n)) ↔ Primrec₂ f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → β → σ
⊢ (Primrec₂ fun a n => (decode n).bind (some ∘ f a)) ↔ Primrec₂ f

tactic: exact bind_decode_iff.trans Primrec₂.option_some_iff
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → β → σ
⊢ (Primrec₂ fun a n => (decode n).bind (some ∘ f a)) ↔ Primrec₂ f
state_after: no goals
Theorem: BoxIntegral.Prepartition.restrict_mono
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: refine ofWithBot_mono fun J₁ hJ₁ hne => ?_
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
⊢ π₁.restrict J ≤ π₂.restrict J
state_after: ι : Type u_1
I J J₁✝ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : WithBot (Box ι)
hJ₁ : J₁ ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₁.boxes
hne : J₁ ≠ ⊥
⊢ ∃ J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes, J₁ ≤ J'

tactic: rw [Finset.mem_image] at hJ₁
state_before: ι : Type u_1
I J J₁✝ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : WithBot (Box ι)
hJ₁ : J₁ ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₁.boxes
hne : J₁ ≠ ⊥
⊢ ∃ J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes, J₁ ≤ J'
state_after: ι : Type u_1
I J J₁✝ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : WithBot (Box ι)
hJ₁ : ∃ a ∈ π₁.boxes, ↑J ⊓ ↑a = J₁
hne : J₁ ≠ ⊥
⊢ ∃ J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes, J₁ ≤ J'

tactic: rcases hJ₁ with ⟨J₁, hJ₁, rfl⟩
state_before: ι : Type u_1
I J J₁✝ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : WithBot (Box ι)
hJ₁ : ∃ a ∈ π₁.boxes, ↑J ⊓ ↑a = J₁
hne : J₁ ≠ ⊥
⊢ ∃ J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes, J₁ ≤ J'
state_after: case intro.intro
ι : Type u_1
I J J₁✝ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : Box ι
hJ₁ : J₁ ∈ π₁.boxes
hne : ↑J ⊓ ↑J₁ ≠ ⊥
⊢ ∃ J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes, ↑J ⊓ ↑J₁ ≤ J'

tactic: rcases Hle hJ₁ with ⟨J₂, hJ₂, hle⟩
state_before: case intro.intro
ι : Type u_1
I J J₁✝ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : Box ι
hJ₁ : J₁ ∈ π₁.boxes
hne : ↑J ⊓ ↑J₁ ≠ ⊥
⊢ ∃ J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes, ↑J ⊓ ↑J₁ ≤ J'
state_after: case intro.intro.intro.intro
ι : Type u_1
I J J₁✝ J₂✝ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : Box ι
hJ₁ : J₁ ∈ π₁.boxes
hne : ↑J ⊓ ↑J₁ ≠ ⊥
J₂ : Box ι
hJ₂ : J₂ ∈ π₂
hle : J₁ ≤ J₂
⊢ ∃ J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes, ↑J ⊓ ↑J₁ ≤ J'

tactic: exact ⟨_, Finset.mem_image_of_mem _ hJ₂, inf_le_inf_left _ <| WithBot.coe_le_coe.2 hle⟩
state_before: case intro.intro.intro.intro
ι : Type u_1
I J J₁✝ J₂✝ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : Box ι
hJ₁ : J₁ ∈ π₁.boxes
hne : ↑J ⊓ ↑J₁ ≠ ⊥
J₂ : Box ι
hJ₂ : J₂ ∈ π₂
hle : J₁ ≤ J₂
⊢ ∃ J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes, ↑J ⊓ ↑J₁ ≤ J'
state_after: no goals
Theorem: Complex.tan_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [tan, neg_div]
state_before: x y : ℂ
⊢ tan (-x) = -tan x
state_after: no goals
Theorem: IntermediateField.adjoin_simple_le_iff
File: Mathlib/FieldTheory/Adjoin.lean

tactic: simp
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
K : IntermediateField F E
⊢ F⟮α⟯ ≤ K ↔ α ∈ K
state_after: no goals
Theorem: isUnit_of_mul_isUnit_left
File: Mathlib/Algebra/Group/Units.lean

tactic: rwa [← mul_assoc]
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : CommMonoid M
x y : M
hu : IsUnit (x * y)
z : M
hz : x * y * z = 1
⊢ x * (y * z) = 1
state_after: no goals
Theorem: Batteries.UnionFind.equiv_rootD_l
File: .lake/packages/batteries/Batteries/Data/UnionFind/Lemmas.lean

tactic: simp [Equiv, rootD_rootD]
state_before: self : UnionFind
a b : Nat
⊢ self.Equiv (self.rootD a) b ↔ self.Equiv a b
state_after: no goals
Theorem: Polynomial.eval₂_X_mul
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: rw [X_mul, eval₂_mul_X]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
⊢ eval₂ f x (X * p) = eval₂ f x p * x
state_after: no goals
Theorem: MeasureTheory.VectorMeasure.le_iff'
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: refine ⟨fun h i => ?_, fun h i _ => h i⟩
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
u v w : VectorMeasure α M
⊢ v ≤ w ↔ ∀ (i : Set α), ↑v i ≤ ↑w i
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
u v w : VectorMeasure α M
h : v ≤ w
i : Set α
⊢ ↑v i ≤ ↑w i

tactic: by_cases hi : MeasurableSet i
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
u v w : VectorMeasure α M
h : v ≤ w
i : Set α
⊢ ↑v i ≤ ↑w i
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
u v w : VectorMeasure α M
h : v ≤ w
i : Set α
hi : MeasurableSet i
⊢ ↑v i ≤ ↑w i

case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
u v w : VectorMeasure α M
h : v ≤ w
i : Set α
hi : ¬MeasurableSet i
⊢ ↑v i ≤ ↑w i

tactic: exact h i hi
state_before: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
u v w : VectorMeasure α M
h : v ≤ w
i : Set α
hi : MeasurableSet i
⊢ ↑v i ≤ ↑w i
state_after: no goals

tactic: rw [v.not_measurable hi, w.not_measurable hi]
state_before: case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
u v w : VectorMeasure α M
h : v ≤ w
i : Set α
hi : ¬MeasurableSet i
⊢ ↑v i ≤ ↑w i
state_after: no goals
Theorem: NonUnitalStarAlgebra.sInf_toNonUnitalSubalgebra
File: Mathlib/Algebra/Star/NonUnitalSubalgebra.lean

tactic: simp
state_before: F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : StarRing R
inst✝¹⁴ : NonUnitalSemiring A
inst✝¹³ : StarRing A
inst✝¹² : Module R A
inst✝¹¹ : IsScalarTower R A A
inst✝¹⁰ : SMulCommClass R A A
inst✝⁹ : StarModule R A
inst✝⁸ : NonUnitalSemiring B
inst✝⁷ : StarRing B
inst✝⁶ : Module R B
inst✝⁵ : IsScalarTower R B B
inst✝⁴ : SMulCommClass R B B
inst✝³ : StarModule R B
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
S : Set (NonUnitalStarSubalgebra R A)
⊢ ↑(sInf S).toNonUnitalSubalgebra = ↑(sInf (toNonUnitalSubalgebra '' S))
state_after: no goals
Theorem: Finset.le_sum_card_inter
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

tactic: apply (s.card_nsmul_le_sum _ _ h).trans
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
s : Finset α
B : Finset (Finset α)
n : ℕ
h : ∀ a ∈ s, n ≤ (filter (fun x => a ∈ x) B).card
⊢ s.card * n ≤ ∑ t ∈ B, (s ∩ t).card
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
s : Finset α
B : Finset (Finset α)
n : ℕ
h : ∀ a ∈ s, n ≤ (filter (fun x => a ∈ x) B).card
⊢ ∑ x ∈ s, (filter (fun x_1 => x ∈ x_1) B).card ≤ ∑ t ∈ B, (s ∩ t).card

tactic: simp_rw [← filter_mem_eq_inter, card_eq_sum_ones, sum_filter]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
s : Finset α
B : Finset (Finset α)
n : ℕ
h : ∀ a ∈ s, n ≤ (filter (fun x => a ∈ x) B).card
⊢ ∑ x ∈ s, (filter (fun x_1 => x ∈ x_1) B).card ≤ ∑ t ∈ B, (s ∩ t).card
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
s : Finset α
B : Finset (Finset α)
n : ℕ
h : ∀ a ∈ s, n ≤ (filter (fun x => a ∈ x) B).card
⊢ (∑ x ∈ s, ∑ a ∈ B, if x ∈ a then 1 else 0) ≤ ∑ x ∈ B, ∑ a ∈ s, if a ∈ x then 1 else 0

tactic: exact sum_comm.le
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
s : Finset α
B : Finset (Finset α)
n : ℕ
h : ∀ a ∈ s, n ≤ (filter (fun x => a ∈ x) B).card
⊢ (∑ x ∈ s, ∑ a ∈ B, if x ∈ a then 1 else 0) ≤ ∑ x ∈ B, ∑ a ∈ s, if a ∈ x then 1 else 0
state_after: no goals
Theorem: MeasureTheory.NullMeasurableSet.of_preimage_fst
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rwa [prod_univ]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁸ : MeasurableSpace α
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝³ : NormedAddCommGroup E
inst✝² : SFinite ν
inst✝¹ : SFinite μ
inst✝ : NeZero ν
s : Set α
h : NullMeasurableSet (Prod.fst ⁻¹' s) (μ.prod ν)
⊢ NullMeasurableSet (s ×ˢ ?m.137355) (μ.prod ?m.137351)
state_after: no goals
Theorem: AffineSubspace.parallel_bot_iff_eq_bot
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: refine ⟨fun h => ?_, fun h => h ▸ Parallel.refl _⟩
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
⊢ s ∥ ⊥ ↔ s = ⊥
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
h : s ∥ ⊥
⊢ s = ⊥

tactic: rcases h with ⟨v, h⟩
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
h : s ∥ ⊥
⊢ s = ⊥
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
v : V
h : ⊥ = map (↑(constVAdd k P v)) s
⊢ s = ⊥

tactic: rwa [eq_comm, map_eq_bot_iff] at h
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
v : V
h : ⊥ = map (↑(constVAdd k P v)) s
⊢ s = ⊥
state_after: no goals
Theorem: CategoryTheory.Limits.epi_of_target_iso_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: rw [zero_of_source_iso_zero g i, zero_of_source_iso_zero h i]
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : Y ≅ 0
Z : C
g h : Y ⟶ Z
x✝ : f ≫ g = f ≫ h
⊢ g = h
state_after: no goals
Theorem: star_pos_iff
File: Mathlib/Algebra/Star/Order.lean

tactic: simpa using star_lt_star_iff (x := 0) (y := x)
state_before: R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
x : R
⊢ 0 < star x ↔ 0 < x
state_after: no goals
Theorem: Finset.min'_mem
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp only [Finset.min, min', id_eq, coe_inf']
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
⊢ s.min = ↑(s.min' H)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
⊢ s.inf WithTop.some = s.inf (WithTop.some ∘ fun x => x)

tactic: rfl
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
⊢ s.inf WithTop.some = s.inf (WithTop.some ∘ fun x => x)
state_after: no goals