tasksource/leandojo huggingface dataset:
Theorem: StructureGroupoid.LocalInvariantProp.congr_set
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: obtain ⟨o, host, ho, hxo⟩ := mem_nhds_iff.mp hu.mem_iff
state_before: H : Type u_1
M : Type ?u.1376
H' : Type ?u.1379
M' : Type ?u.1382
X : Type ?u.1385
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
s✝ t✝ u : Set H
x✝ : H
hG : LocalInvariantProp G G' P
s t : Set H
x : H
f : H → H'
hu : s =ᶠ[𝓝 x] t
⊢ P f s x ↔ P f t x

tactic: simp_rw [subset_def, mem_setOf, ← and_congr_left_iff, ← mem_inter_iff, ← Set.ext_iff] at host
state_before: case intro.intro.intro
H : Type u_1
M : Type ?u.1376
H' : Type ?u.1379
M' : Type ?u.1382
X : Type ?u.1385
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
s✝ t✝ u : Set H
x✝ : H
hG : LocalInvariantProp G G' P
s t : Set H
x : H
f : H → H'
hu : s =ᶠ[𝓝 x] t
o : Set H
host : o ⊆ {x | (fun x => x ∈ s ↔ x ∈ t) x}
ho : IsOpen o
hxo : x ∈ o
⊢ P f s x ↔ P f t x

tactic: rw [hG.is_local ho hxo, host, ← hG.is_local ho hxo]
state_before: case intro.intro.intro
H : Type u_1
M : Type ?u.1376
H' : Type ?u.1379
M' : Type ?u.1382
X : Type ?u.1385
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
P : (H → H') → Set H → H → Prop
s✝ t✝ u : Set H
x✝ : H
hG : LocalInvariantProp G G' P
s t : Set H
x : H
f : H → H'
hu : s =ᶠ[𝓝 x] t
o : Set H
ho : IsOpen o
hxo : x ∈ o
host : s ∩ o = t ∩ o
⊢ P f s x ↔ P f t x
Theorem: Stream'.WSeq.LiftRel.symm
File: Mathlib/Data/Seq/WSeq.lean

tactic: rwa [LiftRel.swap, H.swap_eq] at h
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Symmetric R
s1 s2 : WSeq α
h : Function.swap (LiftRel R) s2 s1
⊢ LiftRel R s2 s1
Theorem: Submodule.smul_singleton
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: conv_lhs => rw [← span_eq M]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ ↑Set.up {a} • M = map (LinearMap.mulLeft R a) M

tactic: change span _ _ * span _ _ = _
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ ↑Set.up {a} • span R ↑M = map (LinearMap.mulLeft R a) M

tactic: rw [span_mul_span]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ span R (↑SetSemiring.down (↑Set.up {a})) * span R ↑M = map (LinearMap.mulLeft R a) M

tactic: apply le_antisymm
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ span R (↑SetSemiring.down (↑Set.up {a}) * ↑M) = map (LinearMap.mulLeft R a) M

tactic: rw [span_le]
state_before: case a
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ span R (↑SetSemiring.down (↑Set.up {a}) * ↑M) ≤ map (LinearMap.mulLeft R a) M

tactic: rintro _ ⟨b, m, hb, hm, rfl⟩
state_before: case a
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ ↑SetSemiring.down (↑Set.up {a}) * ↑M ⊆ ↑(map (LinearMap.mulLeft R a) M)

tactic: rw [SetLike.mem_coe, mem_map, Set.mem_singleton_iff.mp hb]
state_before: case a.intro.intro.intro.intro
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m✝ n a : A
M : Submodule R A
b m : A
hb : b ∈ ↑SetSemiring.down (↑Set.up {a})
hm : m ∈ ↑M
⊢ (fun x x_1 => x * x_1) b m ∈ ↑(map (LinearMap.mulLeft R a) M)

tactic: exact ⟨m, hm, rfl⟩
state_before: case a.intro.intro.intro.intro
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m✝ n a : A
M : Submodule R A
b m : A
hb : b ∈ ↑SetSemiring.down (↑Set.up {a})
hm : m ∈ ↑M
⊢ ∃ y, y ∈ M ∧ ↑(LinearMap.mulLeft R a) y = (fun x x_1 => x * x_1) a m

tactic: rintro _ ⟨m, hm, rfl⟩
state_before: case a
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n a : A
M : Submodule R A
⊢ map (LinearMap.mulLeft R a) M ≤ span R (↑SetSemiring.down (↑Set.up {a}) * ↑M)

tactic: exact subset_span ⟨a, m, Set.mem_singleton a, hm, rfl⟩
state_before: case a.intro.intro
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m✝ n a : A
M : Submodule R A
m : A
hm : m ∈ ↑M
⊢ ↑(LinearMap.mulLeft R a) m ∈ span R (↑SetSemiring.down (↑Set.up {a}) * ↑M)
Theorem: FirstOrder.Language.Theory.SemanticallyEquivalent.all
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: simp_rw [SemanticallyEquivalent, ModelsBoundedFormula, BoundedFormula.realize_iff,
  BoundedFormula.realize_all]
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ ψ : BoundedFormula L α (n + 1)
h : SemanticallyEquivalent T φ ψ
⊢ SemanticallyEquivalent T (∀'φ) (∀'ψ)

tactic: exact fun M v xs => forall_congr' fun a => h.realize_bd_iff
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ ψ : BoundedFormula L α (n + 1)
h : SemanticallyEquivalent T φ ψ
⊢ ∀ (M : ModelType T) (v : α → ↑M) (xs : Fin n → ↑M),
    (∀ (a : ↑M), BoundedFormula.Realize φ v (Fin.snoc xs a)) ↔ ∀ (a : ↑M), BoundedFormula.Realize ψ v (Fin.snoc xs a)
Theorem: PrimeSpectrum.coe_vanishingIdeal
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: ext f
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
⊢ ↑(vanishingIdeal t) = {f | ∀ (x : PrimeSpectrum R), x ∈ t → f ∈ x.asIdeal}

tactic: rw [vanishingIdeal, SetLike.mem_coe, Submodule.mem_iInf]
state_before: case h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
f : R
⊢ f ∈ ↑(vanishingIdeal t) ↔ f ∈ {f | ∀ (x : PrimeSpectrum R), x ∈ t → f ∈ x.asIdeal}

tactic: apply forall_congr'
state_before: case h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
f : R
⊢ (∀ (i : PrimeSpectrum R), f ∈ ⨅ (_ : i ∈ t), i.asIdeal) ↔ f ∈ {f | ∀ (x : PrimeSpectrum R), x ∈ t → f ∈ x.asIdeal}

tactic: intro x
state_before: case h.h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
f : R
⊢ ∀ (a : PrimeSpectrum R), (f ∈ ⨅ (_ : a ∈ t), a.asIdeal) ↔ a ∈ t → f ∈ a.asIdeal

tactic: rw [Submodule.mem_iInf]
state_before: case h.h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
f : R
x : PrimeSpectrum R
⊢ (f ∈ ⨅ (_ : x ∈ t), x.asIdeal) ↔ x ∈ t → f ∈ x.asIdeal
Theorem: exists_eq_or_imp
File: Std/Logic.lean

tactic: simp only [or_and_right, exists_or, exists_eq_left]
state_before: α : Sort u_1
p q : α → Prop
b : Prop
a' : α
⊢ (∃ a, (a = a' ∨ q a) ∧ p a) ↔ p a' ∨ ∃ a, q a ∧ p a
Theorem: Complex.ofReal_neg
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [ofReal']
state_before: r : ℝ
⊢ (↑(-r)).re = (-↑r).re ∧ (↑(-r)).im = (-↑r).im
Theorem: inf_iSup₂_eq
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simp only [inf_iSup_eq]
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort u_1
inst✝ : Frame α
s t : Set α
a✝ b : α
f : (i : ι) → κ i → α
a : α
⊢ (a ⊓ ⨆ (i : ι) (j : κ i), f i j) = ⨆ (i : ι) (j : κ i), a ⊓ f i j
Theorem: Int.even_xor'_odd
File: Mathlib/Data/Int/Parity.lean

tactic: cases even_or_odd n with
| inl h => exact Or.inl ⟨h, even_iff_not_odd.mp h⟩
| inr h => exact Or.inr ⟨h, odd_iff_not_even.mp h⟩
state_before: m n✝ n : ℤ
⊢ Xor' (Even n) (Odd n)

tactic: exact Or.inl ⟨h, even_iff_not_odd.mp h⟩
state_before: case inl
m n✝ n : ℤ
h : Even n
⊢ Xor' (Even n) (Odd n)

tactic: exact Or.inr ⟨h, odd_iff_not_even.mp h⟩
state_before: case inr
m n✝ n : ℤ
h : Odd n
⊢ Xor' (Even n) (Odd n)
Theorem: Finset.normalize_gcd
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: simp [gcd_def]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.15758
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
⊢ ↑normalize (gcd s f) = gcd s f
Theorem: linearEquiv_det_rotation
File: Mathlib/Analysis/Complex/Isometry.lean

tactic: rw [← Units.eq_iff, LinearEquiv.coe_det, det_rotation, Units.val_one]
state_before: a : { x // x ∈ circle }
⊢ ↑LinearEquiv.det (↑rotation a).toLinearEquiv = 1
Theorem: LinearMap.baseChange_neg
File: Mathlib/RingTheory/TensorProduct.lean

tactic: ext
state_before: R : Type u_4
A : Type u_1
B : Type ?u.493982
M : Type u_2
N : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring A
inst✝⁶ : Algebra R A
inst✝⁵ : Ring B
inst✝⁴ : Algebra R B
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f g : M →ₗ[R] N
⊢ baseChange A (-f) = -baseChange A f

tactic: simp [baseChange_eq_ltensor, tmul_neg]
state_before: case a.h.h
R : Type u_4
A : Type u_1
B : Type ?u.493982
M : Type u_2
N : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : Ring A
inst✝⁶ : Algebra R A
inst✝⁵ : Ring B
inst✝⁴ : Algebra R B
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f g : M →ₗ[R] N
x✝ : M
⊢ ↑(↑(AlgebraTensorModule.curry (baseChange A (-f))) 1) x✝ = ↑(↑(AlgebraTensorModule.curry (-baseChange A f)) 1) x✝
Theorem: ProbabilityTheory.iIndepFun.mul
File: Mathlib/Probability/Independence/Basic.lean

tactic: have : IndepFun (fun ω => (f i ω, f j ω)) (f k) μ :=
  hf_Indep.indepFun_prod hf_meas i j k hik hjk
state_before: Ω : Type u_1
ι✝ : Type ?u.3504903
β✝ : Type ?u.3504906
β' : Type ?u.3504909
γ : Type ?u.3504912
γ' : Type ?u.3504915
mΩ : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
f✝ : Ω → β✝
g : Ω → β'
inst✝² : IsProbabilityMeasure μ
ι : Type u_2
β : Type u_3
m : MeasurableSpace β
inst✝¹ : Mul β
inst✝ : MeasurableMul₂ β
f : ι → Ω → β
hf_Indep : iIndepFun (fun x => m) f
hf_meas : ∀ (i : ι), Measurable (f i)
i j k : ι
hik : i ≠ k
hjk : j ≠ k
⊢ IndepFun (f i * f j) (f k)

tactic: change IndepFun ((fun p : β × β => p.fst * p.snd) ∘ fun ω => (f i ω, f j ω)) (id ∘ f k) μ
state_before: Ω : Type u_1
ι✝ : Type ?u.3504903
β✝ : Type ?u.3504906
β' : Type ?u.3504909
γ : Type ?u.3504912
γ' : Type ?u.3504915
mΩ : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
f✝ : Ω → β✝
g : Ω → β'
inst✝² : IsProbabilityMeasure μ
ι : Type u_2
β : Type u_3
m : MeasurableSpace β
inst✝¹ : Mul β
inst✝ : MeasurableMul₂ β
f : ι → Ω → β
hf_Indep : iIndepFun (fun x => m) f
hf_meas : ∀ (i : ι), Measurable (f i)
i j k : ι
hik : i ≠ k
hjk : j ≠ k
this : IndepFun (fun ω => (f i ω, f j ω)) (f k)
⊢ IndepFun (f i * f j) (f k)

tactic: exact IndepFun.comp this (measurable_fst.mul measurable_snd) measurable_id
state_before: Ω : Type u_1
ι✝ : Type ?u.3504903
β✝ : Type ?u.3504906
β' : Type ?u.3504909
γ : Type ?u.3504912
γ' : Type ?u.3504915
mΩ : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
f✝ : Ω → β✝
g : Ω → β'
inst✝² : IsProbabilityMeasure μ
ι : Type u_2
β : Type u_3
m : MeasurableSpace β
inst✝¹ : Mul β
inst✝ : MeasurableMul₂ β
f : ι → Ω → β
hf_Indep : iIndepFun (fun x => m) f
hf_meas : ∀ (i : ι), Measurable (f i)
i j k : ι
hik : i ≠ k
hjk : j ≠ k
this : IndepFun (fun ω => (f i ω, f j ω)) (f k)
⊢ IndepFun ((fun p => p.fst * p.snd) ∘ fun ω => (f i ω, f j ω)) (id ∘ f k)
Theorem: RingQuot.ringQuot_ext'
File: Mathlib/Algebra/RingQuot.lean

tactic: ext x
state_before: R : Type u₁
inst✝⁶ : Semiring R
S : Type u₂
inst✝⁵ : CommSemiring S
A : Type u₃
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
T : Type u₄
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f g : RingQuot s →ₐ[S] B
w : AlgHom.comp f (mkAlgHom S s) = AlgHom.comp g (mkAlgHom S s)
⊢ f = g

tactic: rcases mkAlgHom_surjective S s x with ⟨x, rfl⟩
state_before: case H
R : Type u₁
inst✝⁶ : Semiring R
S : Type u₂
inst✝⁵ : CommSemiring S
A : Type u₃
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
T : Type u₄
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f g : RingQuot s →ₐ[S] B
w : AlgHom.comp f (mkAlgHom S s) = AlgHom.comp g (mkAlgHom S s)
x : RingQuot s
⊢ ↑f x = ↑g x

tactic: exact AlgHom.congr_fun w x
state_before: case H.intro
R : Type u₁
inst✝⁶ : Semiring R
S : Type u₂
inst✝⁵ : CommSemiring S
A : Type u₃
inst✝⁴ : Semiring A
inst✝³ : Algebra S A
r : R → R → Prop
T : Type u₄
inst✝² : Semiring T
B : Type u₄
inst✝¹ : Semiring B
inst✝ : Algebra S B
s : A → A → Prop
f g : RingQuot s →ₐ[S] B
w : AlgHom.comp f (mkAlgHom S s) = AlgHom.comp g (mkAlgHom S s)
x : A
⊢ ↑f (↑(mkAlgHom S s) x) = ↑g (↑(mkAlgHom S s) x)
Theorem: iSup_inf_eq
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: rw [iSup, sSup_inf_eq, iSup_range]
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort ?u.2411
inst✝ : Frame α
s t : Set α
a✝ b : α
f : ι → α
a : α
⊢ (⨆ (i : ι), f i) ⊓ a = ⨆ (i : ι), f i ⊓ a
Theorem: CategoryTheory.strict_initial
File: Mathlib/CategoryTheory/Closed/Cartesian.lean

tactic: haveI : Mono (prod.lift (𝟙 A) f ≫ (zeroMul t).hom) := mono_comp _ _
state_before: C : Type u
inst✝² : Category C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
⊢ IsIso f

tactic: rw [zeroMul_hom, prod.lift_snd] at this
state_before: C : Type u
inst✝² : Category C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this : Mono (prod.lift (𝟙 A) f ≫ (zeroMul t).hom)
⊢ IsIso f

tactic: haveI : IsSplitEpi f := IsSplitEpi.mk' ⟨t.to _, t.hom_ext _ _⟩
state_before: C : Type u
inst✝² : Category C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this : Mono f
⊢ IsIso f

tactic: apply isIso_of_mono_of_isSplitEpi
state_before: C : Type u
inst✝² : Category C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this✝ : Mono f
this : IsSplitEpi f
⊢ IsIso f
Theorem: IsExposed.convex
File: Mathlib/Analysis/Convex/Exposed.lean

tactic: obtain rfl | hB := B.eq_empty_or_nonempty
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : LinearOrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
A B C : Set E
hAB : IsExposed 𝕜 A B
hA : Convex 𝕜 A
⊢ Convex 𝕜 B

tactic: obtain ⟨l, rfl⟩ := hAB hB
state_before: case inr
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : LinearOrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
A B C : Set E
hAB : IsExposed 𝕜 A B
hA : Convex 𝕜 A
hB : Set.Nonempty B
⊢ Convex 𝕜 B

tactic: exact fun x₁ hx₁ x₂ hx₂ a b ha hb hab =>
  ⟨hA hx₁.1 hx₂.1 ha hb hab, fun y hy =>
    ((l.toLinearMap.concaveOn convex_univ).convex_ge _ ⟨mem_univ _, hx₁.2 y hy⟩
        ⟨mem_univ _, hx₂.2 y hy⟩ ha hb hab).2⟩
state_before: case inr.intro
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : LinearOrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
A C : Set E
hA : Convex 𝕜 A
l : E →L[𝕜] 𝕜
hAB : IsExposed 𝕜 A {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑l y ≤ ↑l x}
hB : Set.Nonempty {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑l y ≤ ↑l x}
⊢ Convex 𝕜 {x | x ∈ A ∧ ∀ (y : E), y ∈ A → ↑l y ≤ ↑l x}

tactic: exact convex_empty
state_before: case inl
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : LinearOrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
A C : Set E
hA : Convex 𝕜 A
hAB : IsExposed 𝕜 A ∅
⊢ Convex 𝕜 ∅
Theorem: BoxIntegral.Box.isSome_iff
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: erw [Option.isSome]
state_before: ι : Type u_1
I J : Box ι
x y : ι → ℝ
⊢ Option.isSome ⊥ = true ↔ Set.Nonempty ↑⊥

tactic: simp
state_before: ι : Type u_1
I J : Box ι
x y : ι → ℝ
⊢ (match ⊥ with
      | some val => true
      | none => false) =
      true ↔
    Set.Nonempty ↑⊥

tactic: erw [Option.isSome]
state_before: ι : Type u_1
I✝ J : Box ι
x y : ι → ℝ
I : Box ι
⊢ Option.isSome ↑I = true ↔ Set.Nonempty ↑↑I

tactic: simp [I.nonempty_coe]
state_before: ι : Type u_1
I✝ J : Box ι
x y : ι → ℝ
I : Box ι
⊢ (match ↑I with
      | some val => true
      | none => false) =
      true ↔
    Set.Nonempty ↑↑I
Theorem: Function.Antiperiodic.sub_eq'
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [sub_eq_neg_add] using h (-x)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.155050
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddCommGroup α
inst✝ : Neg β
h : Antiperiodic f c
⊢ f (c - x) = -f (-x)
Theorem: lub_Iio_eq_self_or_Iio_eq_Iic
File: Mathlib/Order/Bounds/Basic.lean

tactic: cases' eq_or_lt_of_le (lub_Iio_le i hj) with hj_eq_i hj_lt_i
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
⊢ j = i ∨ Iio i = Iic j

tactic: exact Or.inl hj_eq_i
state_before: case inl
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
hj_eq_i : j = i
⊢ j = i ∨ Iio i = Iic j

tactic: right
state_before: case inr
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
hj_lt_i : j < i
⊢ j = i ∨ Iio i = Iic j

tactic: exact Set.ext fun k => ⟨fun hk_lt => hj.1 hk_lt, fun hk_le_j => lt_of_le_of_lt hk_le_j hj_lt_i⟩
state_before: case inr.h
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
hj_lt_i : j < i
⊢ Iio i = Iic j
Theorem: MeasureTheory.extend_mono'
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: refine' le_iInf _
state_before: α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ (i : ℕ), f i)
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    Pairwise (Disjoint on f) → m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i))
msU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i))
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
s₁ s₂ : Set α
h₁ : P s₁
hs : s₁ ⊆ s₂
⊢ extend m s₁ ≤ extend m s₂

tactic: intro h₂
state_before: α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ (i : ℕ), f i)
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    Pairwise (Disjoint on f) → m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i))
msU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i))
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
s₁ s₂ : Set α
h₁ : P s₁
hs : s₁ ⊆ s₂
⊢ ∀ (i : (fun s => P s) s₂), extend m s₁ ≤ m s₂ i

tactic: rw [extend_eq m h₁]
state_before: α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ (i : ℕ), f i)
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    Pairwise (Disjoint on f) → m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i))
msU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i))
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
s₁ s₂ : Set α
h₁ : P s₁
hs : s₁ ⊆ s₂
h₂ : (fun s => P s) s₂
⊢ extend m s₁ ≤ m s₂ h₂

tactic: exact m_mono h₁ h₂ hs
state_before: α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ (i : ℕ), f i)
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    Pairwise (Disjoint on f) → m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i))
msU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i))
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
s₁ s₂ : Set α
h₁ : P s₁
hs : s₁ ⊆ s₂
h₂ : (fun s => P s) s₂
⊢ m s₁ h₁ ≤ m s₂ h₂
Theorem: MeasureTheory.ae_eq_bot
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← empty_mem_iff_bot, mem_ae_iff, compl_empty, measure_univ_eq_zero]
state_before: α : Type u_1
β : Type ?u.548833
γ : Type ?u.548836
δ : Type ?u.548839
ι : Type ?u.548842
R : Type ?u.548845
R' : Type ?u.548848
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
⊢ ae μ = ⊥ ↔ μ = 0
Theorem: MeasureTheory.OuterMeasure.le_pi
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rw [OuterMeasure.pi, le_boundedBy']
state_before: ι : Type u_2
ι' : Type ?u.2059615
α : ι → Type u_1
inst✝ : Fintype ι
m✝ m : (i : ι) → OuterMeasure (α i)
n : OuterMeasure ((i : ι) → α i)
⊢ n ≤ OuterMeasure.pi m ↔
    ∀ (s : (i : ι) → Set (α i)), Set.Nonempty (Set.pi univ s) → ↑n (Set.pi univ s) ≤ ∏ i : ι, ↑(m i) (s i)

tactic: constructor
state_before: ι : Type u_2
ι' : Type ?u.2059615
α : ι → Type u_1
inst✝ : Fintype ι
m✝ m : (i : ι) → OuterMeasure (α i)
n : OuterMeasure ((i : ι) → α i)
⊢ (∀ (s : Set ((i : ι) → α i)), Set.Nonempty s → ↑n s ≤ piPremeasure m s) ↔
    ∀ (s : (i : ι) → Set (α i)), Set.Nonempty (Set.pi univ s) → ↑n (Set.pi univ s) ≤ ∏ i : ι, ↑(m i) (s i)

tactic: intro h s hs
state_before: case mp
ι : Type u_2
ι' : Type ?u.2059615
α : ι → Type u_1
inst✝ : Fintype ι
m✝ m : (i : ι) → OuterMeasure (α i)
n : OuterMeasure ((i : ι) → α i)
⊢ (∀ (s : Set ((i : ι) → α i)), Set.Nonempty s → ↑n s ≤ piPremeasure m s) →
    ∀ (s : (i : ι) → Set (α i)), Set.Nonempty (Set.pi univ s) → ↑n (Set.pi univ s) ≤ ∏ i : ι, ↑(m i) (s i)

tactic: refine' (h _ hs).trans_eq (piPremeasure_pi hs)
state_before: case mp
ι : Type u_2
ι' : Type ?u.2059615
α : ι → Type u_1
inst✝ : Fintype ι
m✝ m : (i : ι) → OuterMeasure (α i)
n : OuterMeasure ((i : ι) → α i)
h : ∀ (s : Set ((i : ι) → α i)), Set.Nonempty s → ↑n s ≤ piPremeasure m s
s : (i : ι) → Set (α i)
hs : Set.Nonempty (Set.pi univ s)
⊢ ↑n (Set.pi univ s) ≤ ∏ i : ι, ↑(m i) (s i)

tactic: intro h s hs
state_before: case mpr
ι : Type u_2
ι' : Type ?u.2059615
α : ι → Type u_1
inst✝ : Fintype ι
m✝ m : (i : ι) → OuterMeasure (α i)
n : OuterMeasure ((i : ι) → α i)
⊢ (∀ (s : (i : ι) → Set (α i)), Set.Nonempty (Set.pi univ s) → ↑n (Set.pi univ s) ≤ ∏ i : ι, ↑(m i) (s i)) →
    ∀ (s : Set ((i : ι) → α i)), Set.Nonempty s → ↑n s ≤ piPremeasure m s

tactic: refine' le_trans (n.mono <| subset_pi_eval_image univ s) (h _ _)
state_before: case mpr
ι : Type u_2
ι' : Type ?u.2059615
α : ι → Type u_1
inst✝ : Fintype ι
m✝ m : (i : ι) → OuterMeasure (α i)
n : OuterMeasure ((i : ι) → α i)
h : ∀ (s : (i : ι) → Set (α i)), Set.Nonempty (Set.pi univ s) → ↑n (Set.pi univ s) ≤ ∏ i : ι, ↑(m i) (s i)
s : Set ((i : ι) → α i)
hs : Set.Nonempty s
⊢ ↑n s ≤ piPremeasure m s

tactic: simp [univ_pi_nonempty_iff, hs]
state_before: case mpr
ι : Type u_2
ι' : Type ?u.2059615
α : ι → Type u_1
inst✝ : Fintype ι
m✝ m : (i : ι) → OuterMeasure (α i)
n : OuterMeasure ((i : ι) → α i)
h : ∀ (s : (i : ι) → Set (α i)), Set.Nonempty (Set.pi univ s) → ↑n (Set.pi univ s) ≤ ∏ i : ι, ↑(m i) (s i)
s : Set ((i : ι) → α i)
hs : Set.Nonempty s
⊢ Set.Nonempty (Set.pi univ fun i => eval i '' s)