tasksource/leandojo huggingface dataset:
Theorem: Filter.extraction_of_frequently_atTop'
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: choose u hu hu' using h
state_before: ι : Type ?u.57426
ι' : Type ?u.57429
α : Type ?u.57432
β : Type ?u.57435
γ : Type ?u.57438
P : ℕ → Prop
h : ∀ (N : ℕ), ∃ n, n > N ∧ P n
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)

tactic: refine ⟨fun n => (u^[n + 1]) 0, strictMono_nat_of_lt_succ fun n => ?_, fun n => ?_⟩
state_before: ι : Type ?u.57426
ι' : Type ?u.57429
α : Type ?u.57432
β : Type ?u.57435
γ : Type ?u.57438
P : ℕ → Prop
u : ℕ → ℕ
hu : ∀ (N : ℕ), u N > N
hu' : ∀ (N : ℕ), P (u N)
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)

tactic: exact Trans.trans (hu _) (Function.iterate_succ_apply' _ _ _).symm
state_before: case refine_1
ι : Type ?u.57426
ι' : Type ?u.57429
α : Type ?u.57432
β : Type ?u.57435
γ : Type ?u.57438
P : ℕ → Prop
u : ℕ → ℕ
hu : ∀ (N : ℕ), u N > N
hu' : ∀ (N : ℕ), P (u N)
n : ℕ
⊢ (u^[n + 1]) 0 < (u^[n + 1 + 1]) 0

tactic: simpa only [Function.iterate_succ_apply'] using hu' _
state_before: case refine_2
ι : Type ?u.57426
ι' : Type ?u.57429
α : Type ?u.57432
β : Type ?u.57435
γ : Type ?u.57438
P : ℕ → Prop
u : ℕ → ℕ
hu : ∀ (N : ℕ), u N > N
hu' : ∀ (N : ℕ), P (u N)
n : ℕ
⊢ P ((fun n => (u^[n + 1]) 0) n)
Theorem: IsPGroup.powEquiv_symm_apply
File: Mathlib/GroupTheory/PGroup.lean

tactic: rw [order_eq_card_zpowers']
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
hG : IsPGroup p G
n : ℕ
hn : Nat.coprime p n
g : G
⊢ ↑(powEquiv hG hn).symm g = g ^ Nat.gcdB (orderOf g) n

tactic: rfl
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
hG : IsPGroup p G
n : ℕ
hn : Nat.coprime p n
g : G
⊢ ↑(powEquiv hG hn).symm g = g ^ Nat.gcdB (Nat.card { x // x ∈ Subgroup.zpowers g }) n
Theorem: StrictMono.induced_topology_eq_preorder
File: Mathlib/Topology/Order/Basic.lean

tactic: refine induced_topology_eq_preorder hf.lt_iff_lt (fun h₁ h₂ => ?_) fun h₁ h₂ => ?_
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : LinearOrder β
t : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : StrictMono f
hc : OrdConnected (range f)
⊢ induced f t = Preorder.topology α

tactic: rcases hc.out (mem_range_self _) (mem_range_self _) ⟨not_lt.1 h₂, h₁.le⟩ with ⟨y, rfl⟩
state_before: case refine_1
α✝ : Type u
β✝ : Type v
γ : Type w
α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : LinearOrder β
t : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : StrictMono f
hc : OrdConnected (range f)
a✝ : α
b✝ : β
x✝ : α
h₁ : b✝ < f a✝
h₂ : ¬b✝ < f x✝
⊢ ∃ y, y < a✝ ∧ b✝ ≤ f y

tactic: exact ⟨y, hf.lt_iff_lt.1 h₁, le_rfl⟩
state_before: case refine_1.intro
α✝ : Type u
β✝ : Type v
γ : Type w
α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : LinearOrder β
t : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : StrictMono f
hc : OrdConnected (range f)
a✝ x✝ y : α
h₁ : f y < f a✝
h₂ : ¬f y < f x✝
⊢ ∃ y_1, y_1 < a✝ ∧ f y ≤ f y_1

tactic: rcases hc.out (mem_range_self _) (mem_range_self _) ⟨h₁.le, not_lt.1 h₂⟩ with ⟨y, rfl⟩
state_before: case refine_2
α✝ : Type u
β✝ : Type v
γ : Type w
α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : LinearOrder β
t : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : StrictMono f
hc : OrdConnected (range f)
a✝ : α
b✝ : β
x✝ : α
h₁ : f a✝ < b✝
h₂ : ¬f x✝ < b✝
⊢ ∃ y, a✝ < y ∧ f y ≤ b✝

tactic: exact ⟨y, hf.lt_iff_lt.1 h₁, le_rfl⟩
state_before: case refine_2.intro
α✝ : Type u
β✝ : Type v
γ : Type w
α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : LinearOrder β
t : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
hf : StrictMono f
hc : OrdConnected (range f)
a✝ x✝ y : α
h₁ : f a✝ < f y
h₂ : ¬f x✝ < f y
⊢ ∃ y_1, a✝ < y_1 ∧ f y_1 ≤ f y
Theorem: Int.ceil_le_floor_add_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [ceil_le, Int.cast_add, Int.cast_one]
state_before: F : Type ?u.210054
α : Type u_1
β : Type ?u.210060
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ ⌈a⌉ ≤ ⌊a⌋ + 1

tactic: exact (lt_floor_add_one a).le
state_before: F : Type ?u.210054
α : Type u_1
β : Type ?u.210060
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ a ≤ ↑⌊a⌋ + 1
Theorem: RingHom.codomain_trivial_iff_range_eq_singleton_zero
File: Mathlib/Algebra/Hom/Ring.lean

tactic: simp [← hx, h x]
state_before: F : Type ?u.88572
α : Type u_2
β : Type u_1
γ : Type ?u.88581
x✝³ : NonAssocSemiring α
x✝² : NonAssocSemiring β
f : α →+* β
x✝¹ y✝ : α
h : ∀ (x : α), ↑f x = 0
y : β
x✝ : y ∈ Set.range ↑f
x : α
hx : ↑f x = y
⊢ y ∈ {0}

tactic: simpa using hy.symm
state_before: F : Type ?u.88572
α : Type u_2
β : Type u_1
γ : Type ?u.88581
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f : α →+* β
x y✝ : α
h : ∀ (x : α), ↑f x = 0
y : β
hy : y ∈ {0}
⊢ ↑f 0 = y
Theorem: Int.cast_mul
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: simp
state_before: F : Type ?u.1324
ι : Type ?u.1327
α : Type u_1
β : Type ?u.1333
inst✝ : NonAssocRing α
m : ℤ
⊢ ∀ (n : ℤ), ↑(0 * n) = ↑0 * ↑n

tactic: simp [add_mul, ih]
state_before: F : Type ?u.1324
ι : Type ?u.1327
α : Type u_1
β : Type ?u.1333
inst✝ : NonAssocRing α
m k : ℤ
x✝ : 0 ≤ k
ih : ∀ (n : ℤ), ↑(k * n) = ↑k * ↑n
n : ℤ
⊢ ↑((k + 1) * n) = ↑(k + 1) * ↑n

tactic: simp [sub_mul, ih]
state_before: F : Type ?u.1324
ι : Type ?u.1327
α : Type u_1
β : Type ?u.1333
inst✝ : NonAssocRing α
m k : ℤ
x✝ : k ≤ 0
ih : ∀ (n : ℤ), ↑(k * n) = ↑k * ↑n
n : ℤ
⊢ ↑((k - 1) * n) = ↑(k - 1) * ↑n
Theorem: Commute.right_comm
File: Mathlib/Algebra/Group/Commute.lean

tactic: simp only [mul_assoc, h.eq]
state_before: G : Type ?u.1760
S : Type u_1
inst✝ : Semigroup S
a✝ b c : S
h : Commute b c
a : S
⊢ a * b * c = a * c * b
Theorem: Nat.factorization_mul_support
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: ext q
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ (factorization (a * b)).support = (factorization a).support ∪ (factorization b).support

tactic: simp only [Finset.mem_union, factor_iff_mem_factorization]
state_before: case a
a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
q : ℕ
⊢ q ∈ (factorization (a * b)).support ↔ q ∈ (factorization a).support ∪ (factorization b).support

tactic: exact mem_factors_mul ha hb
state_before: case a
a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
q : ℕ
⊢ q ∈ factors (a * b) ↔ q ∈ factors a ∨ q ∈ factors b
Theorem: List.filterMap_eq_filterMapTR
File: Std/Data/List/Basic.lean

tactic: funext α β f l
state_before: ⊢ @filterMap = @filterMapTR

tactic: let rec go : ∀ as acc, filterMapTR.go f as acc = acc.data ++ as.filterMap f
  | [], acc => by simp [filterMapTR.go, filterMap]
  | a::as, acc => by simp [filterMapTR.go, filterMap, go as]; split <;> simp [*]
state_before: case h.h.h.h
α : Type u_2
β : Type u_1
f : α → Option β
l : List α
⊢ filterMap f l = filterMapTR f l

tactic: exact (go l #[]).symm
state_before: case h.h.h.h
α : Type u_2
β : Type u_1
f : α → Option β
l : List α
⊢ filterMap f l = filterMapTR f l

tactic: simp [filterMapTR.go, filterMap]
state_before: α : Type u_2
β : Type u_1
f : α → Option β
l : List α
acc : Array β
⊢ filterMapTR.go f [] acc = acc.data ++ filterMap f []

tactic: simp [filterMapTR.go, filterMap, go as]
state_before: α : Type u_2
β : Type u_1
f : α → Option β
l : List α
a : α
as : List α
acc : Array β
⊢ filterMapTR.go f (a :: as) acc = acc.data ++ filterMap f (a :: as)

tactic: split <;> simp [*]
state_before: α : Type u_2
β : Type u_1
f : α → Option β
l : List α
a : α
as : List α
acc : Array β
⊢ (match f a with
    | none => acc.data ++ filterMap f as
    | some b => acc.data ++ b :: filterMap f as) =
    acc.data ++
      match f a with
      | none => filterMap f as
      | some b => b :: filterMap f as
Theorem: nhds_left_sup_nhds_right
File: Mathlib/Topology/Algebra/Order/LeftRight.lean

tactic: rw [← nhdsWithin_union, Iic_union_Ici, nhdsWithin_univ]
state_before: α : Type u_1
β : Type ?u.1151
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
⊢ 𝓝[Iic a] a ⊔ 𝓝[Ici a] a = 𝓝 a
Theorem: MeasureTheory.Measure.lt_iff'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [le_iff', not_forall, not_le]
state_before: α : Type u_1
β : Type ?u.145326
γ : Type ?u.145329
δ : Type ?u.145332
ι : Type ?u.145335
R : Type ?u.145338
R' : Type ?u.145341
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
⊢ ¬ν ≤ μ ↔ ∃ s, ↑↑μ s < ↑↑ν s
Theorem: Real.rpow_inv_le_iff_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: convert le_rpow_inv_iff_of_neg (Real.rpow_pos_of_pos hx z⁻¹) (Real.rpow_pos_of_pos hy z) hz <;>
simp [← Real.rpow_mul hx.le, ← Real.rpow_mul hy.le, ne_of_lt hz]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ x ^ z⁻¹ ≤ y ↔ y ^ z ≤ x
Theorem: CategoryTheory.IsPullback.of_map_of_faithful
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: simpa only [F.map_comp] using H.w
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝¹ : ReflectsLimit (cospan h i) F
inst✝ : Faithful F
H : IsPullback (F.map f) (F.map g) (F.map h) (F.map i)
⊢ F.map (f ≫ h) = F.map (g ≫ i)
Theorem: Equiv.ofLeftInverse'_eq_ofInjective
File: Mathlib/Logic/Equiv/Set.lean

tactic: ext
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
f_inv : β → α
hf : LeftInverse f_inv f
⊢ ofLeftInverse' f f_inv hf = ofInjective f (_ : Injective f)

tactic: simp
state_before: case H.a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
f_inv : β → α
hf : LeftInverse f_inv f
x✝ : α
⊢ ↑(↑(ofLeftInverse' f f_inv hf) x✝) = ↑(↑(ofInjective f (_ : Injective f)) x✝)
Theorem: IsChain.superChain_succChain
File: Mathlib/Order/Chain.lean

tactic: simp only [IsMaxChain, not_and, not_forall, exists_prop, exists_and_left] at hs₂
state_before: α : Type u_1
β : Type ?u.8828
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hs₁ : IsChain r s
hs₂ : ¬IsMaxChain r s
⊢ SuperChain r s (SuccChain r s)

tactic: obtain ⟨t, ht, hst⟩ := hs₂ hs₁
state_before: α : Type u_1
β : Type ?u.8828
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hs₁ : IsChain r s
hs₂ : IsChain r s → ∃ x, IsChain r x ∧ s ⊆ x ∧ ¬s = x
⊢ SuperChain r s (SuccChain r s)

tactic: exact succChain_spec ⟨t, hs₁, ht, ssubset_iff_subset_ne.2 hst⟩
state_before: case intro.intro
α : Type u_1
β : Type ?u.8828
r : α → α → Prop
c c₁ c₂ c₃ s t✝ : Set α
a b x y : α
hs₁ : IsChain r s
hs₂ : IsChain r s → ∃ x, IsChain r x ∧ s ⊆ x ∧ ¬s = x
t : Set α
ht : IsChain r t
hst : s ⊆ t ∧ ¬s = t
⊢ SuperChain r s (SuccChain r s)
Theorem: MvPolynomial.eval₂_cast_comp
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: apply MvPolynomial.induction_on p (fun n => by simp only [eval₂_C, rename_C])
  (fun p q hp hq => by simp only [hp, hq, rename, eval₂_add, AlgHom.map_add])
  fun p n hp => by simp only [eval₂_mul, hp, eval₂_X, comp_apply, map_mul, rename_X, eval₂_mul]
state_before: σ : Type u_2
τ : Type u_3
α : Type ?u.892507
R : Type u_1
S : Type ?u.892513
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
c : ℤ →+* R
g : τ → R
p : MvPolynomial σ ℤ
⊢ eval₂ c (g ∘ f) p = eval₂ c g (↑(rename f) p)

tactic: simp only [eval₂_C, rename_C]
state_before: σ : Type u_2
τ : Type u_3
α : Type ?u.892507
R : Type u_1
S : Type ?u.892513
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
c : ℤ →+* R
g : τ → R
p : MvPolynomial σ ℤ
n : ℤ
⊢ eval₂ c (g ∘ f) (↑C n) = eval₂ c g (↑(rename f) (↑C n))

tactic: simp only [hp, hq, rename, eval₂_add, AlgHom.map_add]
state_before: σ : Type u_2
τ : Type u_3
α : Type ?u.892507
R : Type u_1
S : Type ?u.892513
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
c : ℤ →+* R
g : τ → R
p✝ p q : MvPolynomial σ ℤ
hp : eval₂ c (g ∘ f) p = eval₂ c g (↑(rename f) p)
hq : eval₂ c (g ∘ f) q = eval₂ c g (↑(rename f) q)
⊢ eval₂ c (g ∘ f) (p + q) = eval₂ c g (↑(rename f) (p + q))

tactic: simp only [eval₂_mul, hp, eval₂_X, comp_apply, map_mul, rename_X, eval₂_mul]
state_before: σ : Type u_2
τ : Type u_3
α : Type ?u.892507
R : Type u_1
S : Type ?u.892513
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
c : ℤ →+* R
g : τ → R
p✝ p : MvPolynomial σ ℤ
n : σ
hp : eval₂ c (g ∘ f) p = eval₂ c g (↑(rename f) p)
⊢ eval₂ c (g ∘ f) (p * X n) = eval₂ c g (↑(rename f) (p * X n))
Theorem: List.chain_append_singleton_iff_forall₂
File: Mathlib/Data/List/Chain.lean

tactic: simp [chain_iff_forall₂]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
⊢ Chain R a (l ++ [b]) ↔ Forall₂ R (a :: l) (l ++ [b])
Theorem: Finset.sup_sup
File: Mathlib/Data/Finset/Lattice.lean

tactic: refine' Finset.cons_induction_on s _ fun b t _ h => _
state_before: F : Type ?u.16149
α : Type u_1
β : Type u_2
γ : Type ?u.16158
ι : Type ?u.16161
κ : Type ?u.16164
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
⊢ sup s (f ⊔ g) = sup s f ⊔ sup s g

tactic: rw [sup_empty, sup_empty, sup_empty, bot_sup_eq]
state_before: case refine'_1
F : Type ?u.16149
α : Type u_1
β : Type u_2
γ : Type ?u.16158
ι : Type ?u.16161
κ : Type ?u.16164
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
⊢ sup ∅ (f ⊔ g) = sup ∅ f ⊔ sup ∅ g

tactic: rw [sup_cons, sup_cons, sup_cons, h]
state_before: case refine'_2
F : Type ?u.16149
α : Type u_1
β : Type u_2
γ : Type ?u.16158
ι : Type ?u.16161
κ : Type ?u.16164
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
b : β
t : Finset β
x✝ : ¬b ∈ t
h : sup t (f ⊔ g) = sup t f ⊔ sup t g
⊢ sup (cons b t x✝) (f ⊔ g) = sup (cons b t x✝) f ⊔ sup (cons b t x✝) g

tactic: exact sup_sup_sup_comm _ _ _ _
state_before: case refine'_2
F : Type ?u.16149
α : Type u_1
β : Type u_2
γ : Type ?u.16158
ι : Type ?u.16161
κ : Type ?u.16164
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
b : β
t : Finset β
x✝ : ¬b ∈ t
h : sup t (f ⊔ g) = sup t f ⊔ sup t g
⊢ (f ⊔ g) b ⊔ (sup t f ⊔ sup t g) = f b ⊔ sup t f ⊔ (g b ⊔ sup t g)
Theorem: AffineSubspace.wOppSide_self_iff
File: Mathlib/Analysis/Convex/Side.lean

tactic: constructor
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.226912
P : Type u_3
P' : Type ?u.226918
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x : P
⊢ WOppSide s x x ↔ x ∈ s

tactic: rintro ⟨p₁, hp₁, p₂, hp₂, h⟩
state_before: case mp
R : Type u_1
V : Type u_2
V' : Type ?u.226912
P : Type u_3
P' : Type ?u.226918
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x : P
⊢ WOppSide s x x → x ∈ s

tactic: obtain ⟨a, -, -, -, -, h₁, -⟩ := h.exists_eq_smul_add
state_before: case mp.intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type ?u.226912
P : Type u_3
P' : Type ?u.226918
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (p₂ -ᵥ x)
⊢ x ∈ s

tactic: rw [add_comm, vsub_add_vsub_cancel, ← eq_vadd_iff_vsub_eq] at h₁
state_before: case mp.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type ?u.226912
P : Type u_3
P' : Type ?u.226918
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (p₂ -ᵥ x)
a : R
h₁ : x -ᵥ p₁ = a • (x -ᵥ p₁ + (p₂ -ᵥ x))
⊢ x ∈ s

tactic: rw [h₁]
state_before: case mp.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type ?u.226912
P : Type u_3
P' : Type ?u.226918
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (p₂ -ᵥ x)
a : R
h₁ : x = a • (p₂ -ᵥ p₁) +ᵥ p₁
⊢ x ∈ s

tactic: exact s.smul_vsub_vadd_mem a hp₂ hp₁ hp₁
state_before: case mp.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type ?u.226912
P : Type u_3
P' : Type ?u.226918
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (p₂ -ᵥ x)
a : R
h₁ : x = a • (p₂ -ᵥ p₁) +ᵥ p₁
⊢ a • (p₂ -ᵥ p₁) +ᵥ p₁ ∈ s

tactic: exact fun h => ⟨x, h, x, h, SameRay.rfl⟩
state_before: case mpr
R : Type u_1
V : Type u_2
V' : Type ?u.226912
P : Type u_3
P' : Type ?u.226918
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x : P
⊢ x ∈ s → WOppSide s x x
Theorem: InnerProductGeometry.angle_eq_pi_iff
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [angle, ← real_inner_div_norm_mul_norm_eq_neg_one_iff, Real.arccos_eq_pi, LE.le.le_iff_eq]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ angle x y = π ↔ x ≠ 0 ∧ ∃ r, r < 0 ∧ y = r • x

tactic: exact (abs_le.mp (abs_real_inner_div_norm_mul_norm_le_one x y)).1
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ -1 ≤ inner x y / (‖x‖ * ‖y‖)
Theorem: geom_sum_succ
File: Mathlib/Algebra/GeomSum.lean

tactic: simp only [mul_sum, ← pow_succ, sum_range_succ', pow_zero]
state_before: α : Type u
inst✝ : Semiring α
x : α
n : ℕ
⊢ ∑ i in range (n + 1), x ^ i = x * ∑ i in range n, x ^ i + 1
Theorem: Filter.map₂_swap
File: Mathlib/Order/Filter/NAry.lean

tactic: ext u
state_before: α : Type u_1
α' : Type ?u.29406
β : Type u_2
β' : Type ?u.29412
γ : Type u_3
γ' : Type ?u.29418
δ : Type ?u.29421
δ' : Type ?u.29424
ε : Type ?u.29427
ε' : Type ?u.29430
m✝ : α → β → γ
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → β → γ
f : Filter α
g : Filter β
⊢ map₂ m f g = map₂ (fun a b => m b a) g f

tactic: constructor <;> rintro ⟨s, t, hs, ht, hu⟩ <;> refine' ⟨t, s, ht, hs, by rwa [image2_swap]⟩
state_before: case a
α : Type u_1
α' : Type ?u.29406
β : Type u_2
β' : Type ?u.29412
γ : Type u_3
γ' : Type ?u.29418
δ : Type ?u.29421
δ' : Type ?u.29424
ε : Type ?u.29427
ε' : Type ?u.29430
m✝ : α → β → γ
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u✝ : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → β → γ
f : Filter α
g : Filter β
u : Set γ
⊢ u ∈ map₂ m f g ↔ u ∈ map₂ (fun a b => m b a) g f

tactic: rwa [image2_swap]
state_before: α : Type u_1
α' : Type ?u.29406
β : Type u_2
β' : Type ?u.29412
γ : Type u_3
γ' : Type ?u.29418
δ : Type ?u.29421
δ' : Type ?u.29424
ε : Type ?u.29427
ε' : Type ?u.29430
m✝ : α → β → γ
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
u✝ : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → β → γ
f : Filter α
g : Filter β
u : Set γ
s : Set β
t : Set α
hs : s ∈ g
ht : t ∈ f
hu : image2 (fun a b => m b a) s t ⊆ u
⊢ image2 m t s ⊆ u
Theorem: CategoryTheory.Limits.CompleteLattice.pushout_eq_sup
File: Mathlib/CategoryTheory/Limits/Lattice.lean

tactic: rw [finite_colimit_eq_finset_univ_sup]
state_before: α : Type u
J : Type w
inst✝³ : SmallCategory J
inst✝² : FinCategory J
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
x y z : α
f : z ⟶ x
g : z ⟶ y
⊢ colimit (span f g) = Finset.sup Finset.univ (span f g).toPrefunctor.obj

tactic: rw [sup_bot_eq]
state_before: α : Type u
J : Type w
inst✝³ : SmallCategory J
inst✝² : FinCategory J
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
x y z : α
f : z ⟶ x
g : z ⟶ y
⊢ z ⊔ (x ⊔ (y ⊔ ⊥)) = z ⊔ (x ⊔ y)
Theorem: OrthonormalBasis.volume_parallelepiped
File: Mathlib/MeasureTheory/Measure/Haar/InnerProductSpace.lean

tactic: haveI : Fact (finrank ℝ F = finrank ℝ F) := ⟨rfl⟩
state_before: ι : Type u_1
F : Type u_2
inst✝⁵ : Fintype ι
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : FiniteDimensional ℝ F
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
b : OrthonormalBasis ι ℝ F
⊢ ↑↑volume (parallelepiped ↑b) = 1

tactic: let o := (stdOrthonormalBasis ℝ F).toBasis.orientation
state_before: ι : Type u_1
F : Type u_2
inst✝⁵ : Fintype ι
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : FiniteDimensional ℝ F
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
b : OrthonormalBasis ι ℝ F
this : Fact (finrank ℝ F = finrank ℝ F)
⊢ ↑↑volume (parallelepiped ↑b) = 1

tactic: rw [← o.measure_eq_volume]
state_before: ι : Type u_1
F : Type u_2
inst✝⁵ : Fintype ι
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : FiniteDimensional ℝ F
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
b : OrthonormalBasis ι ℝ F
this : Fact (finrank ℝ F = finrank ℝ F)
o : Orientation ℝ F (Fin (finrank ℝ F)) := Basis.orientation (OrthonormalBasis.toBasis (stdOrthonormalBasis ℝ F))
⊢ ↑↑volume (parallelepiped ↑b) = 1

tactic: exact o.measure_orthonormalBasis b
state_before: ι : Type u_1
F : Type u_2
inst✝⁵ : Fintype ι
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : FiniteDimensional ℝ F
inst✝¹ : MeasurableSpace F
inst✝ : BorelSpace F
b : OrthonormalBasis ι ℝ F
this : Fact (finrank ℝ F = finrank ℝ F)
o : Orientation ℝ F (Fin (finrank ℝ F)) := Basis.orientation (OrthonormalBasis.toBasis (stdOrthonormalBasis ℝ F))
⊢ ↑↑(AlternatingMap.measure (Orientation.volumeForm o)) (parallelepiped ↑b) = 1
Theorem: SemidirectProduct.lift_unique
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: ext
state_before: N : Type ?u.177654
G : Type ?u.177657
H : Type ?u.177660
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h :
  ∀ (g : G),
    MonoidHom.comp f₁ (MulEquiv.toMonoidHom (↑φ g)) = MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑f₂ g))) f₁
F : N ⋊[φ] G →* H
x✝ : G
⊢ MonoidHom.comp (MonoidHom.comp F inl) (MulEquiv.toMonoidHom (↑φ x✝)) =
    MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑(MonoidHom.comp F inr) x✝))) (MonoidHom.comp F inl)

tactic: simp [inl_aut]
state_before: case h
N : Type ?u.177654
G : Type ?u.177657
H : Type ?u.177660
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h :
  ∀ (g : G),
    MonoidHom.comp f₁ (MulEquiv.toMonoidHom (↑φ g)) = MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑f₂ g))) f₁
F : N ⋊[φ] G →* H
x✝¹ : G
x✝ : N
⊢ ↑(MonoidHom.comp (MonoidHom.comp F inl) (MulEquiv.toMonoidHom (↑φ x✝¹))) x✝ =
    ↑(MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑(MonoidHom.comp F inr) x✝¹))) (MonoidHom.comp F inl)) x✝

tactic: rw [FunLike.ext_iff]
state_before: N : Type u_2
G : Type u_1
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h :
  ∀ (g : G),
    MonoidHom.comp f₁ (MulEquiv.toMonoidHom (↑φ g)) = MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑f₂ g))) f₁
F : N ⋊[φ] G →* H
⊢ F =
    lift (MonoidHom.comp F inl) (MonoidHom.comp F inr)
      (_ :
        ∀ (x : G),
          MonoidHom.comp (MonoidHom.comp F inl) (MulEquiv.toMonoidHom (↑φ x)) =
            MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑(MonoidHom.comp F inr) x))) (MonoidHom.comp F inl))

tactic: simp only [lift, MonoidHom.comp_apply, MonoidHom.coe_mk, OneHom.coe_mk, ← map_mul,
  inl_left_mul_inr_right, forall_const]
state_before: N : Type u_2
G : Type u_1
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h :
  ∀ (g : G),
    MonoidHom.comp f₁ (MulEquiv.toMonoidHom (↑φ g)) = MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑f₂ g))) f₁
F : N ⋊[φ] G →* H
⊢ ∀ (x : N ⋊[φ] G),
    ↑F x =
      ↑(lift (MonoidHom.comp F inl) (MonoidHom.comp F inr)
            (_ :
              ∀ (x : G),
                MonoidHom.comp (MonoidHom.comp F inl) (MulEquiv.toMonoidHom (↑φ x)) =
                  MonoidHom.comp (MulEquiv.toMonoidHom (↑MulAut.conj (↑(MonoidHom.comp F inr) x)))
                    (MonoidHom.comp F inl)))
        x