ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matrix.fromBlocks_submatrix_sum_swap_sum_swap
File: Mathlib/Data/Matrix/Block.lean

Proof steps:
state_before: l✝ : Type u_1
m✝ : Type u_2
n✝ : Type u_3
o✝ : Type u_4
p : Type u_5
q : Type u_6
m' : o✝ → Type u_7
n' : o✝ → Type u_8
p' : o✝ → Type u_9
R : Type u_10
S : Type u_11
α✝ : Type u_12
β : Type u_13
l : Type u_14
m : Type u_15
n : Type u_16
o : Type u_17
α : Type u_18
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
⊢ (fromBlocks A B C D).submatrix Sum.swap Sum.swap = fromBlocks D C B A
state_after: no goals
tactic: simp
Theorem: LinearMap.toMatrix₂'_mul
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

Proof steps:
state_before: R✝ : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M✝ : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
R : Type u_17
inst✝⁸ : CommSemiring R
inst✝⁷ : Fintype n
inst✝⁶ : Fintype m
inst✝⁵ : DecidableEq n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : (n → R) →ₗ[R] (m → R) →ₗ[R] R
M : Matrix m m' R
⊢ (toMatrix₂' R) B * M = (toMatrix₂' R) (B.compl₂ (toLin' M))
state_after: no goals
tactic: simp only [B.toMatrix₂'_compl₂, toMatrix'_toLin']
Theorem: exists_open_nhds_one_split
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : MulOneClass M
inst✝ : ContinuousMul M
s : Set M
hs : s ∈ 𝓝 1
⊢ ∃ V, IsOpen V ∧ 1 ∈ V ∧ ∀ v ∈ V, ∀ w ∈ V, v * w ∈ s
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : MulOneClass M
inst✝ : ContinuousMul M
s : Set M
hs : s ∈ 𝓝 1
this : (fun a => a.1 * a.2) ⁻¹' s ∈ 𝓝 (1, 1)
⊢ ∃ V, IsOpen V ∧ 1 ∈ V ∧ ∀ v ∈ V, ∀ w ∈ V, v * w ∈ s
tactic: have : (fun a : M × M => a.1 * a.2) ⁻¹' s ∈ 𝓝 ((1, 1) : M × M) :=
    tendsto_mul (by simpa only [one_mul] using hs)
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : MulOneClass M
inst✝ : ContinuousMul M
s : Set M
hs : s ∈ 𝓝 1
this : (fun a => a.1 * a.2) ⁻¹' s ∈ 𝓝 (1, 1)
⊢ ∃ V, IsOpen V ∧ 1 ∈ V ∧ ∀ v ∈ V, ∀ w ∈ V, v * w ∈ s
state_after: no goals
tactic: simpa only [prod_subset_iff] using exists_nhds_square this
Theorem: SimpleGraph.Subgraph.neighborSet_sInf
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
s : Set G.Subgraph
v : V
⊢ (sInf s).neighborSet v = (⋂ G' ∈ s, G'.neighborSet v) ∩ G.neighborSet v
state_after: case h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
s : Set G.Subgraph
v x✝ : V
⊢ x✝ ∈ (sInf s).neighborSet v ↔ x✝ ∈ (⋂ G' ∈ s, G'.neighborSet v) ∩ G.neighborSet v
tactic: ext
state_before: case h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
s : Set G.Subgraph
v x✝ : V
⊢ x✝ ∈ (sInf s).neighborSet v ↔ x✝ ∈ (⋂ G' ∈ s, G'.neighborSet v) ∩ G.neighborSet v
state_after: no goals
tactic: simp
Theorem: Finset.max_singleton
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
a : α
⊢ {a}.max = ↑a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
a : α
⊢ (insert a ∅).max = ↑a
tactic: rw [← insert_emptyc_eq]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
a : α
⊢ (insert a ∅).max = ↑a
state_after: no goals
tactic: exact max_insert
Theorem: neg_mul_comm
File: Mathlib/Algebra/Ring/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Mul α
inst✝ : HasDistribNeg α
a b : α
⊢ -a * b = a * -b
state_after: no goals
tactic: simp
Theorem: CategoryTheory.equivYoneda'_hom_val
File: Mathlib/CategoryTheory/Sites/Types.lean

Proof steps:
state_before: S : SheafOfTypes typesGrothendieckTopology
⊢ { val := (equivYoneda S.val ⋯).hom } ≫ { val := (equivYoneda S.val ⋯).inv } = 𝟙 S
state_after: case w
S : SheafOfTypes typesGrothendieckTopology
⊢ ({ val := (equivYoneda S.val ⋯).hom } ≫ { val := (equivYoneda S.val ⋯).inv }).val = (𝟙 S).val
tactic: ext1
state_before: case w
S : SheafOfTypes typesGrothendieckTopology
⊢ ({ val := (equivYoneda S.val ⋯).hom } ≫ { val := (equivYoneda S.val ⋯).inv }).val = (𝟙 S).val
state_after: no goals
tactic: apply (equivYoneda S.1 S.2).hom_inv_id
state_before: S : SheafOfTypes typesGrothendieckTopology
⊢ { val := (equivYoneda S.val ⋯).inv } ≫ { val := (equivYoneda S.val ⋯).hom } =
    𝟙 (yoneda'.obj (S.val.obj (op PUnit.{?u.18004 + 1})))
state_after: case w
S : SheafOfTypes typesGrothendieckTopology
⊢ ({ val := (equivYoneda S.val ⋯).inv } ≫ { val := (equivYoneda S.val ⋯).hom }).val =
    (𝟙 (yoneda'.obj (S.val.obj (op PUnit.{?u.18004 + 1})))).val
tactic: ext1
state_before: case w
S : SheafOfTypes typesGrothendieckTopology
⊢ ({ val := (equivYoneda S.val ⋯).inv } ≫ { val := (equivYoneda S.val ⋯).hom }).val =
    (𝟙 (yoneda'.obj (S.val.obj (op PUnit.{?u.18004 + 1})))).val
state_after: no goals
tactic: apply (equivYoneda S.1 S.2).inv_hom_id
Theorem: LieAlgebra.IsKilling.chainTopCoeff_of_eq_zsmul_add
File: Mathlib/Algebra/Lie/Weights/RootSystem.lean

Proof steps:
state_before: K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
hα : α.IsNonZero
β' : Weight K (↥H) L
n : ℤ
hβ' : ⇑β' = n • ⇑α + ⇑β
⊢ ↑(chainTopCoeff (⇑α) β') = ↑(chainTopCoeff (⇑α) β) - n
state_after: case a
K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
hα : α.IsNonZero
β' : Weight K (↥H) L
n : ℤ
hβ' : ⇑β' = n • ⇑α + ⇑β
⊢ ↑(chainTopCoeff (⇑α) β') ≤ ↑(chainTopCoeff (⇑α) β) - n

case a
K : Type u_1
L : Type u_2
inst✝⁷ : Field K
inst✝⁶ : CharZero K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra K L
inst✝³ : IsKilling K L
inst✝² : FiniteDimensional K L
H : LieSubalgebra K L
inst✝¹ : H.IsCartanSubalgebra
inst✝ : IsTriangularizable K (↥H) L
α β : Weight K (↥H) L
hα : α.IsNonZero
β' : Weight K (↥H) L
n : ℤ
hβ' : ⇑β' = n • ⇑α + ⇑β
⊢ ↑(chainTopCoeff (⇑α) β) - n ≤ ↑(chainTopCoeff (⇑α) β')
tactic: apply le_antisymm
Theorem: CategoryTheory.ShortComplex.leftRightHomologyComparison'_naturality
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
φ : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₁.RightHomologyData
h₁' : S₂.LeftHomologyData
h₂' : S₂.RightHomologyData
⊢ leftHomologyMap' φ h₁ h₁' ≫ leftRightHomologyComparison' h₁' h₂' =
    leftRightHomologyComparison' h₁ h₂ ≫ rightHomologyMap' φ h₂ h₂'
state_after: no goals
tactic: simp only [← cancel_epi h₁.π, ← cancel_mono h₂'.ι, assoc,
    leftHomologyπ_naturality'_assoc, rightHomologyι_naturality',
    π_leftRightHomologyComparison'_ι, π_leftRightHomologyComparison'_ι_assoc,
    cyclesMap'_i_assoc, p_opcyclesMap']
Theorem: Finset.eq_one_of_prod_eq_one
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
a : α
hp : ∏ x ∈ s, f x = 1
h1 : ∀ x ∈ s, x ≠ a → f x = 1
⊢ ∀ x ∈ s, f x = 1
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
a : α
hp : ∏ x ∈ s, f x = 1
h1 : ∀ x ∈ s, x ≠ a → f x = 1
x : α
hx : x ∈ s
⊢ f x = 1
tactic: intro x hx
Theorem: Orientation.volumeForm_zero_pos
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
n : ℕ
_i✝ : Fact (finrank ℝ E = n)
o : Orientation ℝ E (Fin n)
_i : Fact (finrank ℝ E = 0)
⊢ positiveOrientation.volumeForm = AlternatingMap.constLinearEquivOfIsEmpty 1
state_after: no goals
tactic: simp [volumeForm, Or.by_cases, if_pos]
Theorem: uniformEquicontinuous_iff_uniformContinuous
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
⊢ UniformEquicontinuous F ↔ UniformContinuous (⇑UniformFun.ofFun ∘ swap F)
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
⊢ UniformEquicontinuous F ↔
    ∀ i ∈ 𝓤 α,
      ∀ᶠ (x : β × β) in 𝓤 β, ((⇑UniformFun.ofFun ∘ swap F) x.1, (⇑UniformFun.ofFun ∘ swap F) x.2) ∈ UniformFun.gen ι α i
tactic: rw [UniformContinuous, (UniformFun.hasBasis_uniformity ι α).tendsto_right_iff]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
⊢ UniformEquicontinuous F ↔
    ∀ i ∈ 𝓤 α,
      ∀ᶠ (x : β × β) in 𝓤 β, ((⇑UniformFun.ofFun ∘ swap F) x.1, (⇑UniformFun.ofFun ∘ swap F) x.2) ∈ UniformFun.gen ι α i
state_after: no goals
tactic: rfl
Theorem: Finpartition.ne_bot
File: Mathlib/Order/Partition/Finpartition.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
b : α
hb : b ∈ P.parts
⊢ b ≠ ⊥
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
b : α
hb : b ∈ P.parts
h : b = ⊥
⊢ False
tactic: intro h
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
b : α
hb : b ∈ P.parts
h : b = ⊥
⊢ False
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
b : α
hb : b ∈ P.parts
h : b = ⊥
⊢ ⊥ ∈ P.parts
tactic: refine P.not_bot_mem (?_)
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
b : α
hb : b ∈ P.parts
h : b = ⊥
⊢ ⊥ ∈ P.parts
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
b : α
hb : ⊥ ∈ P.parts
h : b = ⊥
⊢ ⊥ ∈ P.parts
tactic: rw [h] at hb
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
b : α
hb : ⊥ ∈ P.parts
h : b = ⊥
⊢ ⊥ ∈ P.parts
state_after: no goals
tactic: exact hb
Theorem: CategoryTheory.IsPushout.of_isColimit
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
c : PushoutCocone f g
h : IsColimit c
⊢ c.inl ≫ (Iso.refl c.pt).hom = (PushoutCocone.mk c.inl c.inr ⋯).inl
state_after: no goals
tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
c : PushoutCocone f g
h : IsColimit c
⊢ c.inr ≫ (Iso.refl c.pt).hom = (PushoutCocone.mk c.inl c.inr ⋯).inr
state_after: no goals
tactic: aesop_cat
Theorem: iSup_ne_bot_subtype
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
⊢ ⨆ i, f ↑i = ⨆ i, f i
state_after: case pos
α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ∀ (i : ι), f i = ⊥
⊢ ⨆ i, f ↑i = ⨆ i, f i

case neg
α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
⊢ ⨆ i, f ↑i = ⨆ i, f i
tactic: by_cases htriv : ∀ i, f i = ⊥
state_before: case neg
α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
⊢ ⨆ i, f ↑i = ⨆ i, f i
state_after: case neg
α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
i : ι
⊢ ∃ i', f i ≤ f ↑i'
tactic: refine (iSup_comp_le f _).antisymm (iSup_mono' fun i => ?_)
state_before: case neg
α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
i : ι
⊢ ∃ i', f i ≤ f ↑i'
state_after: case pos
α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
i : ι
hi : f i = ⊥
⊢ ∃ i', f i ≤ f ↑i'

case neg
α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
i : ι
hi : ¬f i = ⊥
⊢ ∃ i', f i ≤ f ↑i'
tactic: by_cases hi : f i = ⊥
Theorem: Multiset.prod_map_sum
File: Mathlib/Algebra/BigOperators/Ring/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CommSemiring α
s : Multiset (Multiset α)
⊢ (map sum 0).prod = (map prod (Sections 0)).sum
state_after: no goals
tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CommSemiring α
s✝ : Multiset (Multiset α)
a : Multiset α
s : Multiset (Multiset α)
ih : (map sum s).prod = (map prod s.Sections).sum
⊢ (map sum (a ::ₘ s)).prod = (map prod (a ::ₘ s).Sections).sum
state_after: no goals
tactic: simp [ih, map_bind, sum_map_mul_left, sum_map_mul_right]
Theorem: Set.definable_univ
File: Mathlib/ModelTheory/Definability.lean

Proof steps:
state_before: M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
⊢ univ = setOf ⊤.Realize
state_after: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
x✝ : α → M
⊢ x✝ ∈ univ ↔ x✝ ∈ setOf ⊤.Realize
tactic: ext
state_before: case h
M : Type w
A : Set M
L : Language
inst✝ : L.Structure M
α : Type u₁
β : Type u_1
B : Set M
s : Set (α → M)
x✝ : α → M
⊢ x✝ ∈ univ ↔ x✝ ∈ setOf ⊤.Realize
state_after: no goals
tactic: simp
Theorem: Univ.isSubmonoid
File: Mathlib/Deprecated/Submonoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type u_2
inst✝ : AddMonoid A
t : Set A
⊢ IsSubmonoid Set.univ
state_after: no goals
tactic: constructor <;> simp
Theorem: isMulFreimanHom_two
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hf : MapsTo f A B ∧ ∀ a ∈ A, ∀ b ∈ A, ∀ c ∈ A, ∀ d ∈ A, a * b = c * d → f a * f b = f c * f d
⊢ ∀ ⦃s t : Multiset α⦄,
    (∀ ⦃x : α⦄, x ∈ s → x ∈ A) →
      (∀ ⦃x : α⦄, x ∈ t → x ∈ A) → card s = 2 → card t = 2 → s.prod = t.prod → (map f s).prod = (map f t).prod
state_after: no goals
tactic: aesop (add simp [Multiset.card_eq_two])
Theorem: Monotone.disjointed_succ_sup
File: Mathlib/Order/Disjointed.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
hf : Monotone f
n : ℕ
⊢ disjointed f (n + 1) ⊔ f n = f (n + 1)
state_after: α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
hf : Monotone f
n : ℕ
⊢ f n ≤ f (n + 1)
tactic: rw [hf.disjointed_succ, sdiff_sup_cancel]
state_before: α : Type u_1
β : Type u_2
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
hf : Monotone f
n : ℕ
⊢ f n ≤ f (n + 1)
state_after: no goals
tactic: exact hf n.le_succ
Theorem: Set.neg_vadd_set_distrib
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
⊢ (a • s)⁻¹ = op a⁻¹ • s⁻¹
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
x✝ : α
⊢ x✝ ∈ (a • s)⁻¹ ↔ x✝ ∈ op a⁻¹ • s⁻¹
tactic: ext
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
x✝ : α
⊢ x✝ ∈ (a • s)⁻¹ ↔ x✝ ∈ op a⁻¹ • s⁻¹
state_after: no goals
tactic: simp [mem_smul_set_iff_inv_smul_mem]
Theorem: List.prefix_of_prefix_length_le
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : α
l₁ : List α
b : α
l₂ r₁ r₂ : List α
e : b :: l₂ ++ r₂ = a :: l₁ ++ r₁
ll : (a :: l₁).length ≤ (b :: l₂).length
⊢ a :: l₁ <+: b :: l₂
state_after: α : Type u_1
a : α
l₁ : List α
b : α
l₂ r₁ r₂ : List α
ll : (a :: l₁).length ≤ (b :: l₂).length
head_eq✝ : b = a
e' : l₂.append r₂ = l₁.append r₁
⊢ a :: l₁ <+: b :: l₂
tactic: injection e with _ e'
state_before: α : Type u_1
a : α
l₁ : List α
b : α
l₂ r₁ r₂ : List α
ll : (a :: l₁).length ≤ (b :: l₂).length
head_eq✝ : b = a
e' : l₂.append r₂ = l₁.append r₁
⊢ a :: l₁ <+: b :: l₂
state_after: α : Type u_1
a : α
l₁ l₂ r₁ r₂ : List α
e' : l₂.append r₂ = l₁.append r₁
ll : (a :: l₁).length ≤ (a :: l₂).length
⊢ a :: l₁ <+: a :: l₂
tactic: subst b
state_before: α : Type u_1
a : α
l₁ l₂ r₁ r₂ : List α
e' : l₂.append r₂ = l₁.append r₁
ll : (a :: l₁).length ≤ (a :: l₂).length
⊢ a :: l₁ <+: a :: l₂
state_after: case intro
α : Type u_1
a : α
l₁ r₁ r₂ r₃ : List α
e' : (l₁ ++ r₃).append r₂ = l₁.append r₁
ll : (a :: l₁).length ≤ (a :: (l₁ ++ r₃)).length
⊢ a :: l₁ <+: a :: (l₁ ++ r₃)
tactic: rcases prefix_of_prefix_length_le ⟨_, rfl⟩ ⟨_, e'⟩ (le_of_succ_le_succ ll) with ⟨r₃, rfl⟩
state_before: case intro
α : Type u_1
a : α
l₁ r₁ r₂ r₃ : List α
e' : (l₁ ++ r₃).append r₂ = l₁.append r₁
ll : (a :: l₁).length ≤ (a :: (l₁ ++ r₃)).length
⊢ a :: l₁ <+: a :: (l₁ ++ r₃)
state_after: no goals
tactic: exact ⟨r₃, rfl⟩
Theorem: Left.one_le_inv_iff
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ 1 ≤ a⁻¹ ↔ a ≤ 1
state_after: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * 1 ≤ a * a⁻¹ ↔ a ≤ 1
tactic: rw [← mul_le_mul_iff_left a]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * 1 ≤ a * a⁻¹ ↔ a ≤ 1
state_after: no goals
tactic: simp
Theorem: HurwitzZeta.completedHurwitzZetaOdd_neg
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
⊢ completedHurwitzZetaOdd (-a) s = -completedHurwitzZetaOdd a s
state_after: a : UnitAddCircle
s : ℂ
⊢ (∫ (t : ℝ) in Ioi 0, -(↑t ^ ((s + 1) / 2 - 1) • ↑(oddKernel a t))) / 2 =
    -((∫ (t : ℝ) in Ioi 0, ↑t ^ ((s + 1) / 2 - 1) • ↑(oddKernel a t)) / 2)
tactic: simp only [completedHurwitzZetaOdd, StrongFEPair.Λ, hurwitzOddFEPair, mellin, Function.comp_def,
    oddKernel_neg, ofReal_neg, smul_neg]
state_before: a : UnitAddCircle
s : ℂ
⊢ (∫ (t : ℝ) in Ioi 0, -(↑t ^ ((s + 1) / 2 - 1) • ↑(oddKernel a t))) / 2 =
    -((∫ (t : ℝ) in Ioi 0, ↑t ^ ((s + 1) / 2 - 1) • ↑(oddKernel a t)) / 2)
state_after: no goals
tactic: rw [integral_neg, neg_div]
Theorem: Cardinal.max_aleph_eq
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: o₁ o₂ : Ordinal.{u_1}
⊢ max (aleph o₁) (aleph o₂) = aleph (max o₁ o₂)
state_after: case inl
o₁ o₂ : Ordinal.{u_1}
h : aleph o₁ ≤ aleph o₂
⊢ max (aleph o₁) (aleph o₂) = aleph (max o₁ o₂)

case inr
o₁ o₂ : Ordinal.{u_1}
h : aleph o₂ ≤ aleph o₁
⊢ max (aleph o₁) (aleph o₂) = aleph (max o₁ o₂)
tactic: rcases le_total (aleph o₁) (aleph o₂) with h | h
Theorem: norm_exp_mul_sq_le
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/OneVariable.lean

Proof steps:
state_before: τ : ℂ
hτ : 0 < τ.im
n : ℤ
⊢ ‖cexp (↑π * I * ↑n ^ 2 * τ)‖ ≤ rexp (-π * τ.im) ^ n.natAbs
state_after: τ : ℂ
hτ : 0 < τ.im
n : ℤ
y : ℝ := rexp (-π * τ.im)
⊢ ‖cexp (↑π * I * ↑n ^ 2 * τ)‖ ≤ rexp (-π * τ.im) ^ n.natAbs
tactic: let y := rexp (-π * τ.im)
state_before: τ : ℂ
hτ : 0 < τ.im
n : ℤ
y : ℝ := rexp (-π * τ.im)
⊢ ‖cexp (↑π * I * ↑n ^ 2 * τ)‖ ≤ rexp (-π * τ.im) ^ n.natAbs
state_after: τ : ℂ
hτ : 0 < τ.im
n : ℤ
y : ℝ := rexp (-π * τ.im)
h : y < 1
⊢ ‖cexp (↑π * I * ↑n ^ 2 * τ)‖ ≤ rexp (-π * τ.im) ^ n.natAbs
tactic: have h : y < 1 := exp_lt_one_iff.mpr (mul_neg_of_neg_of_pos (neg_lt_zero.mpr pi_pos) hτ)
state_before: τ : ℂ
hτ : 0 < τ.im
n : ℤ
y : ℝ := rexp (-π * τ.im)
h : y < 1
⊢ ‖cexp (↑π * I * ↑n ^ 2 * τ)‖ ≤ rexp (-π * τ.im) ^ n.natAbs
state_after: case refine_1
τ : ℂ
hτ : 0 < τ.im
n : ℤ
y : ℝ := rexp (-π * τ.im)
h : y < 1
⊢ ‖cexp (↑π * I * ↑n ^ 2 * τ)‖ = y ^ n ^ 2

case refine_2
τ : ℂ
hτ : 0 < τ.im
n : ℤ
y : ℝ := rexp (-π * τ.im)
h : y < 1
⊢ y ^ n ^ 2 ≤ rexp (-π * τ.im) ^ n.natAbs
tactic: refine (le_of_eq ?_).trans (?_ : y ^ n ^ 2 ≤ _)