tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Measure.ext_iff_of_sUnion_eq_univ
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rwa [← sUnion_eq_biUnion]
state_before: α : Type u_1
β : Type ?u.320231
γ : Type ?u.320234
δ : Type ?u.320237
ι : Type ?u.320240
R : Type ?u.320243
R' : Type ?u.320246
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
S : Set (Set α)
hc : Set.Countable S
hs : ⋃₀ S = univ
⊢ (⋃ (i : Set α) (_ : i ∈ S), i) = univ
Theorem: FilterBasis.generate
File: Mathlib/Order/Filter/Bases.lean

tactic: apply le_antisymm
state_before: α : Type u_1
β : Type ?u.8511
γ : Type ?u.8514
ι : Sort ?u.8517
ι' : Sort ?u.8520
B : FilterBasis α
⊢ generate B.sets = FilterBasis.filter B

tactic: intro U U_in
state_before: case a
α : Type u_1
β : Type ?u.8511
γ : Type ?u.8514
ι : Sort ?u.8517
ι' : Sort ?u.8520
B : FilterBasis α
⊢ generate B.sets ≤ FilterBasis.filter B

tactic: rcases B.mem_filter_iff.mp U_in with ⟨V, V_in, h⟩
state_before: case a
α : Type u_1
β : Type ?u.8511
γ : Type ?u.8514
ι : Sort ?u.8517
ι' : Sort ?u.8520
B : FilterBasis α
U : Set α
U_in : U ∈ FilterBasis.filter B
⊢ U ∈ generate B.sets

tactic: exact GenerateSets.superset (GenerateSets.basic V_in) h
state_before: case a.intro.intro
α : Type u_1
β : Type ?u.8511
γ : Type ?u.8514
ι : Sort ?u.8517
ι' : Sort ?u.8520
B : FilterBasis α
U : Set α
U_in : U ∈ FilterBasis.filter B
V : Set α
V_in : V ∈ B
h : V ⊆ U
⊢ U ∈ generate B.sets

tactic: rw [le_generate_iff]
state_before: case a
α : Type u_1
β : Type ?u.8511
γ : Type ?u.8514
ι : Sort ?u.8517
ι' : Sort ?u.8520
B : FilterBasis α
⊢ FilterBasis.filter B ≤ generate B.sets

tactic: apply mem_filter_of_mem
state_before: case a
α : Type u_1
β : Type ?u.8511
γ : Type ?u.8514
ι : Sort ?u.8517
ι' : Sort ?u.8520
B : FilterBasis α
⊢ B.sets ⊆ (FilterBasis.filter B).sets
Theorem: List.mem_cyclicPermutations_self
File: Mathlib/Data/List/Rotate.lean

tactic: cases' l with x l
state_before: α : Type u
l✝ l' l : List α
⊢ l ∈ cyclicPermutations l

tactic: simp
state_before: case nil
α : Type u
l l' : List α
⊢ [] ∈ cyclicPermutations []

tactic: rw [mem_iff_nthLe]
state_before: case cons
α : Type u
l✝ l' : List α
x : α
l : List α
⊢ x :: l ∈ cyclicPermutations (x :: l)

tactic: refine' ⟨0, by simp, _⟩
state_before: case cons
α : Type u
l✝ l' : List α
x : α
l : List α
⊢ ∃ n h, nthLe (cyclicPermutations (x :: l)) n h = x :: l

tactic: simp
state_before: case cons
α : Type u
l✝ l' : List α
x : α
l : List α
⊢ nthLe (cyclicPermutations (x :: l)) 0 (_ : 0 < length (cyclicPermutations (x :: l))) = x :: l

tactic: simp
state_before: α : Type u
l✝ l' : List α
x : α
l : List α
⊢ 0 < length (cyclicPermutations (x :: l))
Theorem: Nat.Linear.Poly.denote_combine
File: src/lean/Init/Data/Nat/Linear.lean

tactic: simp [combine, denote_combineAux]
state_before: ctx : Context
p₁ p₂ : Poly
⊢ denote ctx (combine p₁ p₂) = denote ctx p₁ + denote ctx p₂
Theorem: CategoryTheory.solutionSetCondition_of_isRightAdjoint
File: Mathlib/CategoryTheory/Adjunction/AdjointFunctorTheorems.lean

tactic: intro A
state_before: J : Type v
C : Type u
inst✝² : Category C
D : Type u
inst✝¹ : Category D
G : D ⥤ C
inst✝ : IsRightAdjoint G
⊢ SolutionSetCondition G

tactic: refine'
  ⟨PUnit, fun _ => (leftAdjoint G).obj A, fun _ => (Adjunction.ofRightAdjoint G).unit.app A, _⟩
state_before: J : Type v
C : Type u
inst✝² : Category C
D : Type u
inst✝¹ : Category D
G : D ⥤ C
inst✝ : IsRightAdjoint G
A : C
⊢ ∃ ι B f, ∀ (X : D) (h : A ⟶ G.obj X), ∃ i g, f i ≫ G.map g = h

tactic: intro B h
state_before: J : Type v
C : Type u
inst✝² : Category C
D : Type u
inst✝¹ : Category D
G : D ⥤ C
inst✝ : IsRightAdjoint G
A : C
⊢ ∀ (X : D) (h : A ⟶ G.obj X), ∃ i g, (fun x => (Adjunction.ofRightAdjoint G).unit.app A) i ≫ G.map g = h

tactic: refine' ⟨PUnit.unit, ((Adjunction.ofRightAdjoint G).homEquiv _ _).symm h, _⟩
state_before: J : Type v
C : Type u
inst✝² : Category C
D : Type u
inst✝¹ : Category D
G : D ⥤ C
inst✝ : IsRightAdjoint G
A : C
B : D
h : A ⟶ G.obj B
⊢ ∃ i g, (fun x => (Adjunction.ofRightAdjoint G).unit.app A) i ≫ G.map g = h

tactic: rw [← Adjunction.homEquiv_unit, Equiv.apply_symm_apply]
state_before: J : Type v
C : Type u
inst✝² : Category C
D : Type u
inst✝¹ : Category D
G : D ⥤ C
inst✝ : IsRightAdjoint G
A : C
B : D
h : A ⟶ G.obj B
⊢ (fun x => (Adjunction.ofRightAdjoint G).unit.app A) PUnit.unit ≫
      G.map (↑(Adjunction.homEquiv (Adjunction.ofRightAdjoint G) A B).symm h) =
    h
Theorem: Multiset.sup_add
File: Mathlib/Data/Multiset/Lattice.lean

tactic: simp [sup]
state_before: α : Type u_1
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s₁ s₂ : Multiset α
⊢ sup (s₁ + s₂) = fold (fun x x_1 => x ⊔ x_1) (⊥ ⊔ ⊥) (s₁ + s₂)
Theorem: Cardinal.aleph'_pos
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rwa [← aleph'_zero, aleph'_lt]
state_before: o : Ordinal
ho : 0 < o
⊢ 0 < aleph' o
Theorem: Prime.abs
File: Mathlib/RingTheory/Prime.lean

tactic: obtain h | h := abs_choice p <;> rw [h]
state_before: α : Type u_1
inst✝¹ : CommRing α
inst✝ : LinearOrder α
p : α
hp : Prime p
⊢ Prime (Abs.abs p)

tactic: exact hp
state_before: case inl
α : Type u_1
inst✝¹ : CommRing α
inst✝ : LinearOrder α
p : α
hp : Prime p
h : Abs.abs p = p
⊢ Prime p

tactic: exact hp.neg
state_before: case inr
α : Type u_1
inst✝¹ : CommRing α
inst✝ : LinearOrder α
p : α
hp : Prime p
h : Abs.abs p = -p
⊢ Prime (-p)
Theorem: Dfinsupp.mapRange_id
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
h : optParam (∀ (i : ι), id 0 = 0) (_ : ∀ (i : ι), id 0 = id 0)
g : Π₀ (i : ι), β₁ i
⊢ mapRange (fun i => id) h g = g

tactic: rfl
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
h : optParam (∀ (i : ι), id 0 = 0) (_ : ∀ (i : ι), id 0 = id 0)
g : Π₀ (i : ι), β₁ i
i✝ : ι
⊢ ↑(mapRange (fun i => id) h g) i✝ = ↑g i✝
Theorem: Cardinal.prod_eq_of_fintype
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: revert f
state_before: α✝ β α : Type u
h : Fintype α
f : α → Cardinal
⊢ prod f = lift (∏ i : α, f i)

tactic: refine' Fintype.induction_empty_option _ _ _ α (h_fintype := h)
state_before: α✝ β α : Type u
h : Fintype α
⊢ ∀ (f : α → Cardinal), prod f = lift (∏ i : α, f i)

tactic: intro α β hβ e h f
state_before: case refine'_1
α✝ β α : Type u
h : Fintype α
⊢ ∀ (α β : Type u) [inst : Fintype β] (e : α ≃ β),
    (∀ (f : α → Cardinal), prod f = lift (∏ i : α, f i)) → ∀ (f : β → Cardinal), prod f = lift (∏ i : β, f i)

tactic: letI := Fintype.ofEquiv β e.symm
state_before: case refine'_1
α✝¹ β✝ α✝ : Type u
h✝ : Fintype α✝
α β : Type u
hβ : Fintype β
e : α ≃ β
h : ∀ (f : α → Cardinal), prod f = lift (∏ i : α, f i)
f : β → Cardinal
⊢ prod f = lift (∏ i : β, f i)

tactic: rw [← e.prod_comp f, ← h]
state_before: case refine'_1
α✝¹ β✝ α✝ : Type u
h✝ : Fintype α✝
α β : Type u
hβ : Fintype β
e : α ≃ β
h : ∀ (f : α → Cardinal), prod f = lift (∏ i : α, f i)
f : β → Cardinal
this : Fintype α := Fintype.ofEquiv β e.symm
⊢ prod f = lift (∏ i : β, f i)

tactic: exact mk_congr (e.piCongrLeft _).symm
state_before: case refine'_1
α✝¹ β✝ α✝ : Type u
h✝ : Fintype α✝
α β : Type u
hβ : Fintype β
e : α ≃ β
h : ∀ (f : α → Cardinal), prod f = lift (∏ i : α, f i)
f : β → Cardinal
this : Fintype α := Fintype.ofEquiv β e.symm
⊢ prod f = prod fun i => f (↑e i)

tactic: intro f
state_before: case refine'_2
α✝ β α : Type u
h : Fintype α
⊢ ∀ (f : PEmpty → Cardinal), prod f = lift (∏ i : PEmpty, f i)

tactic: rw [Fintype.univ_pempty, Finset.prod_empty, lift_one, Cardinal.prod, mk_eq_one]
state_before: case refine'_2
α✝ β α : Type u
h : Fintype α
f : PEmpty → Cardinal
⊢ prod f = lift (∏ i : PEmpty, f i)

tactic: intro α hα h f
state_before: case refine'_3
α✝ β α : Type u
h : Fintype α
⊢ ∀ (α : Type u) [inst : Fintype α],
    (∀ (f : α → Cardinal), prod f = lift (∏ i : α, f i)) →
      ∀ (f : Option α → Cardinal), prod f = lift (∏ i : Option α, f i)

tactic: rw [Cardinal.prod, mk_congr Equiv.piOptionEquivProd, mk_prod, lift_umax'.{v, u}, mk_out, ←
    Cardinal.prod, lift_prod, Fintype.prod_option, lift_mul, ← h fun a => f (some a)]
state_before: case refine'_3
α✝¹ β α✝ : Type u
h✝ : Fintype α✝
α : Type u
hα : Fintype α
h : ∀ (f : α → Cardinal), prod f = lift (∏ i : α, f i)
f : Option α → Cardinal
⊢ prod f = lift (∏ i : Option α, f i)

tactic: simp only [lift_id]
state_before: case refine'_3
α✝¹ β α✝ : Type u
h✝ : Fintype α✝
α : Type u
hα : Fintype α
h : ∀ (f : α → Cardinal), prod f = lift (∏ i : α, f i)
f : Option α → Cardinal
⊢ (lift (f none) * prod fun i => lift (f (some i))) = lift (f none) * prod fun a => f (some a)
Theorem: LinearEquiv.dualMap_refl
File: Mathlib/LinearAlgebra/Dual.lean

tactic: ext
state_before: R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
⊢ dualMap (refl R M₁) = refl R (Dual R M₁)

tactic: rfl
state_before: case h.h
R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
x✝¹ : Dual R M₁
x✝ : M₁
⊢ ↑(↑(dualMap (refl R M₁)) x✝¹) x✝ = ↑(↑(refl R (Dual R M₁)) x✝¹) x✝
Theorem: Submonoid.iSup_eq_closure
File: Mathlib/GroupTheory/Submonoid/Basic.lean

tactic: simp_rw [Submonoid.closure_iUnion, Submonoid.closure_eq]
state_before: M : Type u_2
N : Type ?u.29826
A : Type ?u.29829
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
ι : Sort u_1
p : ι → Submonoid M
⊢ (⨆ (i : ι), p i) = closure (⋃ (i : ι), ↑(p i))
Theorem: Matrix.vec2_dotProduct'
File: Mathlib/Data/Matrix/Notation.lean

tactic: rw [cons_dotProduct_cons, cons_dotProduct_cons, dotProduct_empty, add_zero]
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : AddCommMonoid α
inst✝ : Mul α
a₀ a₁ b₀ b₁ : α
⊢ ![a₀, a₁] ⬝ᵥ ![b₀, b₁] = a₀ * b₀ + a₁ * b₁
Theorem: Pmf.map_apply
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: simp [map]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.346
f : α → β
p : Pmf α
b : β
⊢ ↑(map f p) b = ∑' (a : α), if b = f a then ↑p a else 0
Theorem: RatFunc.induction_on'
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simpa only [mk_coe_def, Localization.mk_eq_mk'] using
  f p q (mem_nonZeroDivisors_iff_ne_zero.mp q.2)
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : RatFunc K → Prop
x : FractionRing K[X]
f : ∀ (p q : K[X]), q ≠ 0 → P (RatFunc.mk p q)
x✝ : K[X] × { x // x ∈ K[X]⁰ }
p : K[X]
q : { x // x ∈ K[X]⁰ }
⊢ P { toFractionRing := Localization.mk (p, q).fst (p, q).snd }
Theorem: WithTop.map_le_iff
File: Mathlib/Order/WithBot.lean

tactic: erw [← toDual_le_toDual_iff, toDual_map, toDual_map, WithBot.map_le_iff, toDual_le_toDual_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.103518
δ : Type ?u.103521
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a b : WithTop α
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
⊢ map f a ≤ map f b ↔ a ≤ b

tactic: simp [mono_iff]
state_before: case mono_iff
α : Type u_1
β : Type u_2
γ : Type ?u.103518
δ : Type ?u.103521
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
a b : WithTop α
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
⊢ ∀ {a b : αᵒᵈ}, (↑OrderDual.toDual ∘ f ∘ ↑OrderDual.ofDual) a ≤ (↑OrderDual.toDual ∘ f ∘ ↑OrderDual.ofDual) b ↔ a ≤ b
Theorem: List.eraseP_cons_of_pos
File: Std/Data/List/Lemmas.lean

tactic: simp [eraseP_cons, h]
state_before: α : Type u_1
a : α
l : List α
p : α → Bool
h : p a = true
⊢ eraseP p (a :: l) = l
Theorem: CategoryTheory.Limits.prodComparison_inv_natural
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: rw [IsIso.eq_comp_inv, Category.assoc, IsIso.inv_comp_eq, prodComparison_natural]
state_before: C : Type u
inst✝⁷ : Category C
X Y : C
D : Type u₂
inst✝⁶ : Category D
F : C ⥤ D
A A' B B' : C
inst✝⁵ : HasBinaryProduct A B
inst✝⁴ : HasBinaryProduct A' B'
inst✝³ : HasBinaryProduct (F.obj A) (F.obj B)
inst✝² : HasBinaryProduct (F.obj A') (F.obj B')
f : A ⟶ A'
g : B ⟶ B'
inst✝¹ : IsIso (prodComparison F A B)
inst✝ : IsIso (prodComparison F A' B')
⊢ inv (prodComparison F A B) ≫ F.map (prod.map f g) = prod.map (F.map f) (F.map g) ≫ inv (prodComparison F A' B')
Theorem: BoxIntegral.Prepartition.mem_splitCenter
File: Mathlib/Analysis/BoxIntegral/Partition/SubboxInduction.lean

tactic: simp [splitCenter]
state_before: ι : Type u_1
inst✝ : Fintype ι
I J : Box ι
⊢ J ∈ splitCenter I ↔ ∃ s, Box.splitCenterBox I s = J
Theorem: BoundedContinuousFunction.isometry_extend
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: simp [dist_nonneg]
state_before: F : Type ?u.805244
α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : PseudoMetricSpace β
inst✝² : PseudoMetricSpace γ
f✝ g : α →ᵇ β
x : α
C : ℝ
δ : Type u_1
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology δ
f : α ↪ δ
h : δ →ᵇ β
g₁ g₂ : α →ᵇ β
⊢ dist (extend f g₁ h) (extend f g₂ h) = dist g₁ g₂
Theorem: IsSelfAdjoint.mul_star_self
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simpa only [star_star] using star_mul_self (star x)
state_before: R : Type u_1
A : Type ?u.2929
inst✝¹ : Semigroup R
inst✝ : StarSemigroup R
x : R
⊢ IsSelfAdjoint (x * star x)
Theorem: Polynomial.cyclotomic.monic
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: rw [← map_cyclotomic_int]
state_before: n : ℕ
R : Type u_1
inst✝ : Ring R
⊢ Monic (cyclotomic n R)

tactic: exact (int_cyclotomic_spec n).2.2.map _
state_before: n : ℕ
R : Type u_1
inst✝ : Ring R
⊢ Monic (map (Int.castRingHom R) (cyclotomic n ℤ))
Theorem: Array.getElem_mem_data
File: Std/Data/Array/Lemmas.lean

tactic: simp [getElem_eq_data_get, List.get_mem]
state_before: α : Type u_1
i : Nat
a : Array α
h : i < size a
⊢ a[i] ∈ a.data
Theorem: IsScalarTower.Algebra.ext
File: Mathlib/Algebra/Algebra/Tower.lean

tactic: have I := h1
state_before: R : Type u
S✝ : Type v
A✝ : Type w
B : Type u₁
M : Type v₁
inst✝¹² : CommSemiring R
inst✝¹¹ : CommSemiring S✝
inst✝¹⁰ : Semiring A✝
inst✝⁹ : Semiring B
inst✝⁸ : Algebra R S✝
inst✝⁷ : Algebra S✝ A✝
inst✝⁶ : Algebra S✝ B
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B
inst✝³ : IsScalarTower R S✝ A✝
inst✝² : IsScalarTower R S✝ B
S : Type u
A : Type v
inst✝¹ : CommSemiring S
inst✝ : Semiring A
h1 h2 : Algebra S A
r : S
x : A
⊢ A

tactic: exact r • x
state_before: R : Type u
S✝ : Type v
A✝ : Type w
B : Type u₁
M : Type v₁
inst✝¹² : CommSemiring R
inst✝¹¹ : CommSemiring S✝
inst✝¹⁰ : Semiring A✝
inst✝⁹ : Semiring B
inst✝⁸ : Algebra R S✝
inst✝⁷ : Algebra S✝ A✝
inst✝⁶ : Algebra S✝ B
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B
inst✝³ : IsScalarTower R S✝ A✝
inst✝² : IsScalarTower R S✝ B
S : Type u
A : Type v
inst✝¹ : CommSemiring S
inst✝ : Semiring A
h1 h2 : Algebra S A
r : S
x : A
I : Algebra S A
⊢ A

tactic: simpa only [@Algebra.smul_def _ _ _ _ h1, @Algebra.smul_def _ _ _ _ h2, mul_one] using h r 1
state_before: R : Type u
S✝ : Type v
A✝ : Type w
B : Type u₁
M : Type v₁
inst✝¹² : CommSemiring R
inst✝¹¹ : CommSemiring S✝
inst✝¹⁰ : Semiring A✝
inst✝⁹ : Semiring B
inst✝⁸ : Algebra R S✝
inst✝⁷ : Algebra S✝ A✝
inst✝⁶ : Algebra S✝ B
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B
inst✝³ : IsScalarTower R S✝ A✝
inst✝² : IsScalarTower R S✝ B
S : Type u
A : Type v
inst✝¹ : CommSemiring S
inst✝ : Semiring A
h1 h2 : Algebra S A
h :
  ∀ (r : S) (x : A),
    (let_fun I := h1;
      r • x) =
      r • x
r : S
⊢ ↑(algebraMap S A) r = ↑(algebraMap S A) r
Theorem: ENNReal.rpow_le_rpow_of_exponent_ge
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: lift x to ℝ≥0 using ne_of_lt (lt_of_le_of_lt hx1 coe_lt_top)
state_before: x : ℝ≥0∞
y z : ℝ
hx1 : x ≤ 1
hyz : z ≤ y
⊢ x ^ y ≤ x ^ z

tactic: by_cases h : x = 0
state_before: case intro
y z : ℝ
hyz : z ≤ y
x : ℝ≥0
hx1 : ↑x ≤ 1
⊢ ↑x ^ y ≤ ↑x ^ z

tactic: rcases lt_trichotomy y 0 with (Hy | Hy | Hy) <;>
rcases lt_trichotomy z 0 with (Hz | Hz | Hz) <;>
simp [Hy, Hz, h, zero_rpow_of_neg, zero_rpow_of_pos, le_refl] <;>
linarith
state_before: case pos
y z : ℝ
hyz : z ≤ y
x : ℝ≥0
hx1 : ↑x ≤ 1
h : x = 0
⊢ ↑x ^ y ≤ ↑x ^ z

tactic: rw [coe_le_one_iff] at hx1
state_before: case neg
y z : ℝ
hyz : z ≤ y
x : ℝ≥0
hx1 : ↑x ≤ 1
h : ¬x = 0
⊢ ↑x ^ y ≤ ↑x ^ z

tactic: simp [coe_rpow_of_ne_zero h,
  NNReal.rpow_le_rpow_of_exponent_ge (bot_lt_iff_ne_bot.mpr h) hx1 hyz]
state_before: case neg
y z : ℝ
hyz : z ≤ y
x : ℝ≥0
hx1 : x ≤ 1
h : ¬x = 0
⊢ ↑x ^ y ≤ ↑x ^ z
Theorem: Real.quadratic_le_exp_of_nonneg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [Finset.sum_range_succ]
state_before: x✝ y x : ℝ
hx : 0 ≤ x
⊢ 1 + x + x ^ 2 / 2 = ∑ i in range 3, x ^ i / ↑i !

tactic: ring_nf
state_before: x✝ y x : ℝ
hx : 0 ≤ x
⊢ x ^ 2 / 2 = x ^ 2 / (1 + 1)
Theorem: Int.lcm_dvd
File: Mathlib/Data/Int/GCD.lean

tactic: rw [Int.lcm]
state_before: i j k : ℤ
⊢ i ∣ k → j ∣ k → ↑(lcm i j) ∣ k

tactic: intro hi hj
state_before: i j k : ℤ
⊢ i ∣ k → j ∣ k → ↑(Nat.lcm (natAbs i) (natAbs j)) ∣ k

tactic: exact coe_nat_dvd_left.mpr (Nat.lcm_dvd (natAbs_dvd_natAbs.mpr hi) (natAbs_dvd_natAbs.mpr hj))
state_before: i j k : ℤ
hi : i ∣ k
hj : j ∣ k
⊢ ↑(Nat.lcm (natAbs i) (natAbs j)) ∣ k
Theorem: OrthogonalFamily.eq_ite
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: split_ifs with h
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3605350
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_4
dec_ι : DecidableEq ι
G : ι → Type u_3
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
i j : ι
v : G i
w : G j
⊢ inner (↑(V i) v) (↑(V j) w) = if i = j then inner (↑(V i) v) (↑(V j) w) else 0

tactic: rfl
state_before: case inl
𝕜 : Type u_1
E : Type u_2
F : Type ?u.3605350
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_4
dec_ι : DecidableEq ι
G : ι → Type u_3
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
i j : ι
v : G i
w : G j
h : i = j
⊢ inner (↑(V i) v) (↑(V j) w) = inner (↑(V i) v) (↑(V j) w)

tactic: exact hV h v w
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.3605350
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_4
dec_ι : DecidableEq ι
G : ι → Type u_3
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
i j : ι
v : G i
w : G j
h : ¬i = j
⊢ inner (↑(V i) v) (↑(V j) w) = 0
Theorem: Doset.doset_union_leftCoset
File: Mathlib/GroupTheory/DoubleCoset.lean

tactic: ext x
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.64712
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a : G
⊢ (⋃ (h : { x // x ∈ H }), leftCoset (↑h * a) ↑K) = doset a ↑H ↑K

tactic: simp only [mem_leftCoset_iff, mul_inv_rev, Set.mem_iUnion, mem_doset]
state_before: case h
G : Type u_1
inst✝¹ : Group G
α : Type ?u.64712
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
⊢ (x ∈ ⋃ (h : { x // x ∈ H }), leftCoset (↑h * a) ↑K) ↔ x ∈ doset a ↑H ↑K

tactic: constructor
state_before: case h
G : Type u_1
inst✝¹ : Group G
α : Type ?u.64712
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
⊢ (∃ i, a⁻¹ * (↑i)⁻¹ * x ∈ ↑K) ↔ ∃ x_1, x_1 ∈ ↑H ∧ ∃ y, y ∈ ↑K ∧ x = x_1 * a * y

tactic: rintro ⟨y, h_h⟩
state_before: case h.mp
G : Type u_1
inst✝¹ : Group G
α : Type ?u.64712
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
⊢ (∃ i, a⁻¹ * (↑i)⁻¹ * x ∈ ↑K) → ∃ x_1, x_1 ∈ ↑H ∧ ∃ y, y ∈ ↑K ∧ x = x_1 * a * y

tactic: refine' ⟨y, y.2, a⁻¹ * y⁻¹ * x, h_h, _⟩
state_before: case h.mp.intro
G : Type u_1
inst✝¹ : Group G
α : Type ?u.64712
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
y : { x // x ∈ H }
h_h : a⁻¹ * (↑y)⁻¹ * x ∈ ↑K
⊢ ∃ x_1, x_1 ∈ ↑H ∧ ∃ y, y ∈ ↑K ∧ x = x_1 * a * y

tactic: simp only [← mul_assoc, one_mul, mul_right_inv, mul_inv_cancel_right, SubgroupClass.coe_inv]
state_before: case h.mp.intro
G : Type u_1
inst✝¹ : Group G
α : Type ?u.64712
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
y : { x // x ∈ H }
h_h : a⁻¹ * (↑y)⁻¹ * x ∈ ↑K
⊢ x = ↑y * a * (a⁻¹ * ↑y⁻¹ * x)

tactic: rintro ⟨x, hx, y, hy, hxy⟩
state_before: case h.mpr
G : Type u_1
inst✝¹ : Group G
α : Type ?u.64712
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x : G
⊢ (∃ x_1, x_1 ∈ ↑H ∧ ∃ y, y ∈ ↑K ∧ x = x_1 * a * y) → ∃ i, a⁻¹ * (↑i)⁻¹ * x ∈ ↑K

tactic: refine' ⟨⟨x, hx⟩, _⟩
state_before: case h.mpr.intro.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
α : Type ?u.64712
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x✝ x : G
hx : x ∈ ↑H
y : G
hy : y ∈ ↑K
hxy : x✝ = x * a * y
⊢ ∃ i, a⁻¹ * (↑i)⁻¹ * x✝ ∈ ↑K

tactic: simp only [hxy, ← mul_assoc, hy, one_mul, mul_left_inv, Subgroup.coe_mk, inv_mul_cancel_right]
state_before: case h.mpr.intro.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
α : Type ?u.64712
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a x✝ x : G
hx : x ∈ ↑H
y : G
hy : y ∈ ↑K
hxy : x✝ = x * a * y
⊢ a⁻¹ * (↑{ val := x, property := hx })⁻¹ * x✝ ∈ ↑K