ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Integrable.inf
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f g : α → β
hf : Integrable f μ
hg : Integrable g μ
⊢ Integrable (f ⊓ g) μ
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f g : α → β
hf : Memℒp f 1 μ
hg : Memℒp g 1 μ
⊢ Memℒp (f ⊓ g) 1 μ
tactic: rw [← memℒp_one_iff_integrable] at hf hg ⊢
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_5
inst✝ : NormedLatticeAddCommGroup β
f g : α → β
hf : Memℒp f 1 μ
hg : Memℒp g 1 μ
⊢ Memℒp (f ⊓ g) 1 μ
state_after: no goals
tactic: exact hf.inf hg
Theorem: Set.not_subset
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ ¬s ⊆ t ↔ ∃ a ∈ s, a ∉ t
state_after: no goals
tactic: simp only [subset_def, not_forall, exists_prop]
Theorem: Multiset.Pi.forall_rel_cons_ext
File: Mathlib/Data/Multiset/Pi.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
δ : α → Sort u_2
m : Multiset α
a : α
r : ⦃a : α⦄ → δ a → δ a → Prop
b₁ b₂ : δ a
f₁ f₂ : (a' : α) → a' ∈ m → δ a'
hb : r b₁ b₂
hf : ∀ (a : α) (ha : a ∈ m), r (f₁ a ha) (f₂ a ha)
⊢ ∀ (a_1 : α) (ha : a_1 ∈ a ::ₘ m), r (cons m a b₁ f₁ a_1 ha) (cons m a b₂ f₂ a_1 ha)
state_after: α : Type u_1
inst✝ : DecidableEq α
δ : α → Sort u_2
m : Multiset α
a✝ : α
r : ⦃a : α⦄ → δ a → δ a → Prop
b₁ b₂ : δ a✝
f₁ f₂ : (a' : α) → a' ∈ m → δ a'
hb : r b₁ b₂
hf : ∀ (a : α) (ha : a ∈ m), r (f₁ a ha) (f₂ a ha)
a : α
ha : a ∈ a✝ ::ₘ m
⊢ r (cons m a✝ b₁ f₁ a ha) (cons m a✝ b₂ f₂ a ha)
tactic: intro a ha
state_before: α : Type u_1
inst✝ : DecidableEq α
δ : α → Sort u_2
m : Multiset α
a✝ : α
r : ⦃a : α⦄ → δ a → δ a → Prop
b₁ b₂ : δ a✝
f₁ f₂ : (a' : α) → a' ∈ m → δ a'
hb : r b₁ b₂
hf : ∀ (a : α) (ha : a ∈ m), r (f₁ a ha) (f₂ a ha)
a : α
ha : a ∈ a✝ ::ₘ m
⊢ r (cons m a✝ b₁ f₁ a ha) (cons m a✝ b₂ f₂ a ha)
state_after: α : Type u_1
inst✝ : DecidableEq α
δ : α → Sort u_2
m : Multiset α
a✝ : α
r : ⦃a : α⦄ → δ a → δ a → Prop
b₁ b₂ : δ a✝
f₁ f₂ : (a' : α) → a' ∈ m → δ a'
hb : r b₁ b₂
hf : ∀ (a : α) (ha : a ∈ m), r (f₁ a ha) (f₂ a ha)
a : α
ha : a ∈ a✝ ::ₘ m
⊢ r (if h : a = a✝ then ⋯ ▸ b₁ else f₁ a ⋯) (if h : a = a✝ then ⋯ ▸ b₂ else f₂ a ⋯)
tactic: dsimp [cons]
state_before: α : Type u_1
inst✝ : DecidableEq α
δ : α → Sort u_2
m : Multiset α
a✝ : α
r : ⦃a : α⦄ → δ a → δ a → Prop
b₁ b₂ : δ a✝
f₁ f₂ : (a' : α) → a' ∈ m → δ a'
hb : r b₁ b₂
hf : ∀ (a : α) (ha : a ∈ m), r (f₁ a ha) (f₂ a ha)
a : α
ha : a ∈ a✝ ::ₘ m
⊢ r (if h : a = a✝ then ⋯ ▸ b₁ else f₁ a ⋯) (if h : a = a✝ then ⋯ ▸ b₂ else f₂ a ⋯)
state_after: case pos
α : Type u_1
inst✝ : DecidableEq α
δ : α → Sort u_2
m : Multiset α
a✝ : α
r : ⦃a : α⦄ → δ a → δ a → Prop
b₁ b₂ : δ a✝
f₁ f₂ : (a' : α) → a' ∈ m → δ a'
hb : r b₁ b₂
hf : ∀ (a : α) (ha : a ∈ m), r (f₁ a ha) (f₂ a ha)
a : α
ha : a ∈ a✝ ::ₘ m
H : a = a✝
⊢ r (⋯ ▸ b₁) (⋯ ▸ b₂)

case neg
α : Type u_1
inst✝ : DecidableEq α
δ : α → Sort u_2
m : Multiset α
a✝ : α
r : ⦃a : α⦄ → δ a → δ a → Prop
b₁ b₂ : δ a✝
f₁ f₂ : (a' : α) → a' ∈ m → δ a'
hb : r b₁ b₂
hf : ∀ (a : α) (ha : a ∈ m), r (f₁ a ha) (f₂ a ha)
a : α
ha : a ∈ a✝ ::ₘ m
H : ¬a = a✝
⊢ r (f₁ a ⋯) (f₂ a ⋯)
tactic: split_ifs with H
Theorem: Nat.pow_log_le_add_one
File: Mathlib/Data/Nat/Log.lean

Proof steps:
state_before: b : ℕ
⊢ b ^ log b 0 ≤ 0 + 1
state_after: no goals
tactic: rw [log_zero_right, Nat.pow_zero]
Theorem: List.nodup_range
File: Mathlib/Data/List/Range.lean

Proof steps:
state_before: α : Type u
n : ℕ
⊢ (range n).Nodup
state_after: no goals
tactic: simp (config := {decide := true}) only [range_eq_range', nodup_range']
Theorem: CategoryTheory.MonoidalCategory.tensorLeftTensor_inv_app
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y Z : C
⊢ (tensorLeftTensor X Y).inv.app Z = (α_ X Y Z).inv
state_after: no goals
tactic: simp [tensorLeftTensor]
Theorem: CategoryTheory.Limits.Fork.mkHom_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
s t : Fork f g
k : s.pt ⟶ t.pt
w : k ≫ t.ι = s.ι
⊢ ∀ (j : WalkingParallelPair), k ≫ t.π.app j = s.π.app j
state_after: case zero
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
s t : Fork f g
k : s.pt ⟶ t.pt
w : k ≫ t.ι = s.ι
⊢ k ≫ t.π.app zero = s.π.app zero

case one
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
s t : Fork f g
k : s.pt ⟶ t.pt
w : k ≫ t.ι = s.ι
⊢ k ≫ t.π.app one = s.π.app one
tactic: rintro ⟨_ | _⟩
Theorem: AddGroupFilterBasis.cauchy_iff
File: Mathlib/Topology/Algebra/UniformFilterBasis.lean

Proof steps:
state_before: G : Type u_1
inst✝ : AddCommGroup G
B : AddGroupFilterBasis G
F : Filter G
⊢ Cauchy F ↔ F.NeBot ∧ ∀ U ∈ B, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
state_after: G : Type u_1
inst✝ : AddCommGroup G
B : AddGroupFilterBasis G
F : Filter G
this : UniformSpace G := B.uniformSpace
⊢ Cauchy F ↔ F.NeBot ∧ ∀ U ∈ B, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
tactic: letI := B.uniformSpace
state_before: G : Type u_1
inst✝ : AddCommGroup G
B : AddGroupFilterBasis G
F : Filter G
this : UniformSpace G := B.uniformSpace
⊢ Cauchy F ↔ F.NeBot ∧ ∀ U ∈ B, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
state_after: G : Type u_1
inst✝ : AddCommGroup G
B : AddGroupFilterBasis G
F : Filter G
this✝ : UniformSpace G := B.uniformSpace
this : UniformAddGroup G
⊢ Cauchy F ↔ F.NeBot ∧ ∀ U ∈ B, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
tactic: haveI := B.uniformAddGroup
state_before: G : Type u_1
inst✝ : AddCommGroup G
B : AddGroupFilterBasis G
F : Filter G
this✝ : UniformSpace G := B.uniformSpace
this : UniformAddGroup G
⊢ Cauchy F ↔ F.NeBot ∧ ∀ U ∈ B, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
state_after: G : Type u_1
inst✝ : AddCommGroup G
B : AddGroupFilterBasis G
F : Filter G
this✝ : UniformSpace G := B.uniformSpace
this : UniformAddGroup G
⊢ F ×ˢ F ≤ uniformity G ↔ ∀ U ∈ B, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
tactic: suffices F ×ˢ F ≤ uniformity G ↔ ∀ U ∈ B, ∃ M ∈ F, ∀ᵉ (x ∈ M) (y ∈ M), y - x ∈ U by
    constructor <;> rintro ⟨h', h⟩ <;> refine ⟨h', ?_⟩ <;> [rwa [← this]; rwa [this]]
state_before: G : Type u_1
inst✝ : AddCommGroup G
B : AddGroupFilterBasis G
F : Filter G
this✝ : UniformSpace G := B.uniformSpace
this : UniformAddGroup G
⊢ F ×ˢ F ≤ uniformity G ↔ ∀ U ∈ B, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
state_after: G : Type u_1
inst✝ : AddCommGroup G
B : AddGroupFilterBasis G
F : Filter G
this✝ : UniformSpace G := B.uniformSpace
this : UniformAddGroup G
⊢ map (fun x => x.2 - x.1) (F ×ˢ F) ≤ nhds 0 ↔ ∀ U ∈ B, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
tactic: rw [uniformity_eq_comap_nhds_zero G, ← map_le_iff_le_comap]
state_before: G : Type u_1
inst✝ : AddCommGroup G
B : AddGroupFilterBasis G
F : Filter G
this✝ : UniformSpace G := B.uniformSpace
this : UniformAddGroup G
⊢ map (fun x => x.2 - x.1) (F ×ˢ F) ≤ nhds 0 ↔ ∀ U ∈ B, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
state_after: G : Type u_1
inst✝ : AddCommGroup G
B : AddGroupFilterBasis G
F : Filter G
this✝ : UniformSpace G := B.uniformSpace
this : UniformAddGroup G
⊢ Tendsto (fun x => x.2 - x.1) (F ×ˢ F) (nhds 0) ↔ ∀ U ∈ B, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
tactic: change Tendsto _ _ _ ↔ _
state_before: G : Type u_1
inst✝ : AddCommGroup G
B : AddGroupFilterBasis G
F : Filter G
this✝ : UniformSpace G := B.uniformSpace
this : UniformAddGroup G
⊢ Tendsto (fun x => x.2 - x.1) (F ×ˢ F) (nhds 0) ↔ ∀ U ∈ B, ∃ M ∈ F, ∀ x ∈ M, ∀ y ∈ M, y - x ∈ U
state_after: no goals
tactic: simp [(basis_sets F).prod_self.tendsto_iff B.nhds_zero_hasBasis, @forall_swap (_ ∈ _) G]
Theorem: add_div_two_lt_right
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
⊢ (a + b) / 2 < b ↔ a < b
state_after: no goals
tactic: simp [div_lt_iff, mul_two]
Theorem: iUnion_Icc_add_intCast
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
a : α
⊢ ⋃ n, Icc (a + ↑n) (a + ↑n + 1) = univ
state_after: no goals
tactic: simpa only [zsmul_one, Int.cast_add, Int.cast_one, ← add_assoc] using
    iUnion_Icc_add_zsmul zero_lt_one a
Theorem: IsCoprime.of_isCoprime_of_dvd_left
File: Mathlib/RingTheory/Coprime/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime y z
hdvd : x ∣ y
⊢ IsCoprime x z
state_after: case intro
R : Type u
inst✝ : CommSemiring R
x z d : R
h : IsCoprime (x * d) z
⊢ IsCoprime x z
tactic: obtain ⟨d, rfl⟩ := hdvd
state_before: case intro
R : Type u
inst✝ : CommSemiring R
x z d : R
h : IsCoprime (x * d) z
⊢ IsCoprime x z
state_after: no goals
tactic: exact IsCoprime.of_mul_left_left h
Theorem: SemiNormedGrp.explicitCokernelπ_desc_apply
File: Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean

Proof steps:
state_before: X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
cond : f ≫ g = 0
x : ↑Y
⊢ (explicitCokernelπ f ≫ explicitCokernelDesc cond) x = g x
state_after: no goals
tactic: rw [explicitCokernelπ_desc]
Theorem: isSimpleAddGroup_of_prime_card
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α✝ : Type u
a : α✝
inst✝² : Group α✝
α : Type u
inst✝¹ : Group α
inst✝ : Fintype α
p : ℕ
hp : Fact (Nat.Prime p)
h : Fintype.card α = p
⊢ IsSimpleGroup α
state_after: α✝ : Type u
a : α✝
inst✝² : Group α✝
α : Type u
inst✝¹ : Group α
inst✝ : Fintype α
hp : Fact (Nat.Prime (Fintype.card α))
⊢ IsSimpleGroup α
tactic: subst h
state_before: α✝ : Type u
a : α✝
inst✝² : Group α✝
α : Type u
inst✝¹ : Group α
inst✝ : Fintype α
hp : Fact (Nat.Prime (Fintype.card α))
⊢ IsSimpleGroup α
state_after: α✝ : Type u
a : α✝
inst✝² : Group α✝
α : Type u
inst✝¹ : Group α
inst✝ : Fintype α
hp : Fact (Nat.Prime (Fintype.card α))
this : Nontrivial α
⊢ IsSimpleGroup α
tactic: have : Nontrivial α := by
    have h' := Nat.Prime.one_lt hp.out
    exact Fintype.one_lt_card_iff_nontrivial.1 h'
state_before: α✝ : Type u
a : α✝
inst✝² : Group α✝
α : Type u
inst✝¹ : Group α
inst✝ : Fintype α
hp : Fact (Nat.Prime (Fintype.card α))
this : Nontrivial α
⊢ IsSimpleGroup α
state_after: no goals
tactic: exact ⟨fun H _ => H.eq_bot_or_eq_top_of_prime_card⟩
Theorem: supClosure_empty
File: Mathlib/Order/SupClosed.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
s t : Set α
a b : α
⊢ supClosure ∅ = ∅
state_after: no goals
tactic: simp
Theorem: PartENat.withTopEquiv_lt
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: x y : PartENat
⊢ withTopEquiv x < withTopEquiv y ↔ x < y
state_after: no goals
tactic: simp
Theorem: TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivInverse_obj_π_app
File: Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c c' : Cone (SheafConditionEqualizerProducts.diagram F U)
f : c ⟶ c'
⊢ ∀ (j : (CategoryTheory.Pairwise ι)ᵒᵖ),
    f.hom ≫ ((fun c => coneEquivInverseObj F U c) c').π.app j = ((fun c => coneEquivInverseObj F U c) c).π.app j
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c c' : Cone (SheafConditionEqualizerProducts.diagram F U)
f : c ⟶ c'
x : (CategoryTheory.Pairwise ι)ᵒᵖ
⊢ f.hom ≫ ((fun c => coneEquivInverseObj F U c) c').π.app x = ((fun c => coneEquivInverseObj F U c) c).π.app x
tactic: intro x
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c c' : Cone (SheafConditionEqualizerProducts.diagram F U)
f : c ⟶ c'
x : (CategoryTheory.Pairwise ι)ᵒᵖ
⊢ f.hom ≫ ((fun c => coneEquivInverseObj F U c) c').π.app x = ((fun c => coneEquivInverseObj F U c) c).π.app x
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c c' : Cone (SheafConditionEqualizerProducts.diagram F U)
f : c ⟶ c'
x : CategoryTheory.Pairwise ι
⊢ f.hom ≫ ((fun c => coneEquivInverseObj F U c) c').π.app (op x) = ((fun c => coneEquivInverseObj F U c) c).π.app (op x)
tactic: induction x using Opposite.rec' with | h x => ?_
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c c' : Cone (SheafConditionEqualizerProducts.diagram F U)
f : c ⟶ c'
x : CategoryTheory.Pairwise ι
⊢ f.hom ≫ ((fun c => coneEquivInverseObj F U c) c').π.app (op x) = ((fun c => coneEquivInverseObj F U c) c).π.app (op x)
state_after: case h.single
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c c' : Cone (SheafConditionEqualizerProducts.diagram F U)
f : c ⟶ c'
i : ι
⊢ f.hom ≫ ((fun c => coneEquivInverseObj F U c) c').π.app (op (single i)) =
    ((fun c => coneEquivInverseObj F U c) c).π.app (op (single i))

case h.pair
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
c c' : Cone (SheafConditionEqualizerProducts.diagram F U)
f : c ⟶ c'
i j : ι
⊢ f.hom ≫ ((fun c => coneEquivInverseObj F U c) c').π.app (op (Pairwise.pair i j)) =
    ((fun c => coneEquivInverseObj F U c) c).π.app (op (Pairwise.pair i j))
tactic: rcases x with (⟨i⟩ | ⟨i, j⟩)
Theorem: MeasureTheory.piPremeasure_pi
File: Mathlib/MeasureTheory/Constructions/Pi.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
s : (i : ι) → Set (α i)
hs : (univ.pi s).Nonempty
⊢ piPremeasure m (univ.pi s) = ∏ i : ι, (m i) (s i)
state_after: no goals
tactic: simp [hs, piPremeasure]
Theorem: Real.sin_ne_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
⊢ sin x ≠ 0 ↔ ∀ (n : ℤ), ↑n * π ≠ x
state_after: no goals
tactic: rw [← not_exists, not_iff_not, sin_eq_zero_iff]
Theorem: Multiset.all_zero_of_le_zero_le_of_sum_eq_zero
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
⊢ ∀ (a : List α), (∀ x ∈ ⟦a⟧, 1 ≤ x) → prod ⟦a⟧ = 1 → ∀ x ∈ ⟦a⟧, x = 1
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
⊢ ∀ (a : List α), (∀ x ∈ a, 1 ≤ x) → a.prod = 1 → ∀ x ∈ a, x = 1
tactic: simp only [quot_mk_to_coe, prod_coe, mem_coe]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
⊢ ∀ (a : List α), (∀ x ∈ a, 1 ≤ x) → a.prod = 1 → ∀ x ∈ a, x = 1
state_after: no goals
tactic: exact fun l => List.all_one_of_le_one_le_of_prod_eq_one
Theorem: eq_iff_eq_of_lt_iff_lt_of_gt_iff_gt
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
P : Sort u_5
x y x' y' : α
ltc : x < y ↔ x' < y'
gtc : y < x ↔ y' < x'
⊢ x = y ↔ x' = y'
state_after: no goals
tactic: simp_rw [eq_iff_le_not_lt, ← not_lt, ltc, gtc]
Theorem: Finset.sup'_image₂_left
File: Mathlib/Data/Finset/NAry.lean

Proof steps:
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 : γ
inst✝ : SemilatticeSup δ
g : γ → δ
h : (image₂ f s t).Nonempty
⊢ (image₂ f s t).sup' h g = s.sup' ⋯ fun x => t.sup' ⋯ fun x_1 => g (f x x_1)
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 : γ
inst✝ : SemilatticeSup δ
g : γ → δ
h : (image₂ f s t).Nonempty
⊢ (s.sup' ⋯ fun i => t.sup' ⋯ fun i' => (g ∘ uncurry f) (i, i')) = s.sup' ⋯ fun x => t.sup' ⋯ fun x_1 => g (f x x_1)
tactic: simp only [image₂, sup'_image, sup'_product_left]
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 : γ
inst✝ : SemilatticeSup δ
g : γ → δ
h : (image₂ f s t).Nonempty
⊢ (s.sup' ⋯ fun i => t.sup' ⋯ fun i' => (g ∘ uncurry f) (i, i')) = s.sup' ⋯ fun x => t.sup' ⋯ fun x_1 => g (f x x_1)
state_after: no goals
tactic: rfl
Theorem: HahnSeries.order_mul
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

Proof steps:
state_before: Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝³ : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_5
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : NonUnitalNonAssocSemiring R
inst✝ : NoZeroDivisors R
x y : HahnSeries Γ R
hx : x ≠ 0
hy : y ≠ 0
⊢ (x * y).order = x.order + y.order
state_after: case a
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝³ : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_5
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : NonUnitalNonAssocSemiring R
inst✝ : NoZeroDivisors R
x y : HahnSeries Γ R
hx : x ≠ 0
hy : y ≠ 0
⊢ (x * y).order ≤ x.order + y.order

case a
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝³ : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_5
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : NonUnitalNonAssocSemiring R
inst✝ : NoZeroDivisors R
x y : HahnSeries Γ R
hx : x ≠ 0
hy : y ≠ 0
⊢ x.order + y.order ≤ (x * y).order
tactic: apply le_antisymm
Theorem: eq_div_iff_mul_eq'
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ a = b / c ↔ a * c = b
state_after: no goals
tactic: rw [div_eq_mul_inv, eq_mul_inv_iff_mul_eq]
Theorem: groupCohomology.H1LequivOfIsTrivial_comp_H1_π
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝² : CommRing k
inst✝¹ : Group G
A : Rep k G
inst✝ : A.IsTrivial
⊢ ↑(H1LequivOfIsTrivial A) ∘ₗ H1_π A = ↑(oneCocyclesLequivOfIsTrivial A)
state_after: case h.h
k G : Type u
inst✝² : CommRing k
inst✝¹ : Group G
A : Rep k G
inst✝ : A.IsTrivial
x✝¹ : ↥(oneCocycles A)
x✝ : Additive G
⊢ ((↑(H1LequivOfIsTrivial A) ∘ₗ H1_π A) x✝¹) x✝ = (↑(oneCocyclesLequivOfIsTrivial A) x✝¹) x✝
tactic: ext
state_before: case h.h
k G : Type u
inst✝² : CommRing k
inst✝¹ : Group G
A : Rep k G
inst✝ : A.IsTrivial
x✝¹ : ↥(oneCocycles A)
x✝ : Additive G
⊢ ((↑(H1LequivOfIsTrivial A) ∘ₗ H1_π A) x✝¹) x✝ = (↑(oneCocyclesLequivOfIsTrivial A) x✝¹) x✝
state_after: no goals
tactic: rfl
Theorem: Finset.affineCombination_apply_const
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p : P
h : ∑ i ∈ s, w i = 1
⊢ (affineCombination k s fun x => p) w = p
state_after: no goals
tactic: rw [affineCombination_apply, s.weightedVSubOfPoint_apply_const, h, one_smul, vsub_vadd]
Theorem: MeasureTheory.Measure.addHaar_eq_zero_of_disjoint_translates_aux
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

Proof steps:
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : MeasurableSpace E
inst✝² : BorelSpace E
inst✝¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
s : Set E
u : ℕ → E
sb : Bornology.IsBounded s
hu : Bornology.IsBounded (range u)
hs : Pairwise (Disjoint on fun n => {u n} + s)
h's : MeasurableSet s
⊢ μ s = 0
state_after: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : MeasurableSpace E
inst✝² : BorelSpace E
inst✝¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
s : Set E
u : ℕ → E
sb : Bornology.IsBounded s
hu : Bornology.IsBounded (range u)
hs : Pairwise (Disjoint on fun n => {u n} + s)
h's : MeasurableSet s
h : ¬μ s = 0
⊢ False
tactic: by_contra h
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : MeasurableSpace E
inst✝² : BorelSpace E
inst✝¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
s : Set E
u : ℕ → E
sb : Bornology.IsBounded s
hu : Bornology.IsBounded (range u)
hs : Pairwise (Disjoint on fun n => {u n} + s)
h's : MeasurableSet s
h : ¬μ s = 0
⊢ False
state_after: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : MeasurableSpace E
inst✝² : BorelSpace E
inst✝¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
s : Set E
u : ℕ → E
sb : Bornology.IsBounded s
hu : Bornology.IsBounded (range u)
hs : Pairwise (Disjoint on fun n => {u n} + s)
h's : MeasurableSet s
h : ¬μ s = 0
⊢ ⊤ < ⊤
tactic: apply lt_irrefl ∞
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : MeasurableSpace E
inst✝² : BorelSpace E
inst✝¹ : FiniteDimensional ℝ E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
s : Set E
u : ℕ → E
sb : Bornology.IsBounded s
hu : Bornology.IsBounded (range u)
hs : Pairwise (Disjoint on fun n => {u n} + s)
h's : MeasurableSet s
h : ¬μ s = 0
⊢ ⊤ < ⊤
state_after: no goals
tactic: calc
    ∞ = ∑' _ : ℕ, μ s := (ENNReal.tsum_const_eq_top_of_ne_zero h).symm
    _ = ∑' n : ℕ, μ ({u n} + s) := by
      congr 1; ext1 n; simp only [image_add_left, measure_preimage_add, singleton_add]
    _ = μ (⋃ n, {u n} + s) := Eq.symm <| measure_iUnion hs fun n => by
      simpa only [image_add_left, singleton_add] using measurable_id.const_add _ h's
    _ = μ (range u + s) := by rw [← iUnion_add, iUnion_singleton_eq_range]
    _ < ∞ := (hu.add sb).measure_lt_top
Theorem: div_nonneg
File: Mathlib/Algebra/Order/Field/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝⁴ : Semifield α
inst✝³ : LinearOrder α
inst✝² : PosMulReflectLT α
inst✝¹ : ZeroLEOneClass α
a b : α
inst✝ : PosMulMono α
ha : 0 ≤ a
hb : 0 ≤ b
⊢ 0 ≤ a / b
state_after: α : Type u_1
inst✝⁴ : Semifield α
inst✝³ : LinearOrder α
inst✝² : PosMulReflectLT α
inst✝¹ : ZeroLEOneClass α
a b : α
inst✝ : PosMulMono α
ha : 0 ≤ a
hb : 0 ≤ b
⊢ 0 ≤ a * b⁻¹
tactic: rw [div_eq_mul_inv]
state_before: α : Type u_1
inst✝⁴ : Semifield α
inst✝³ : LinearOrder α
inst✝² : PosMulReflectLT α
inst✝¹ : ZeroLEOneClass α
a b : α
inst✝ : PosMulMono α
ha : 0 ≤ a
hb : 0 ≤ b
⊢ 0 ≤ a * b⁻¹
state_after: no goals
tactic: exact mul_nonneg ha (inv_nonneg.2 hb)
Theorem: MeasureTheory.laverage_const
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
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 g : α → ℝ≥0∞
μ : Measure α
inst✝ : IsFiniteMeasure μ
h : NeZero μ
c : ℝ≥0∞
⊢ ⨍⁻ (_x : α), c ∂μ = c
state_after: no goals
tactic: simp only [laverage, lintegral_const, measure_univ, mul_one]