ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Tuple.self_comp_sort
File: Mathlib/Data/Fin/Tuple/Sort.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
⊢ graph.proj ∘ (⇑(graphEquiv₁ f) ∘ ⇑(graphEquiv₁ f).symm) ∘ ⇑(graphEquiv₂ f).toEquiv = graph.proj ∘ ⇑(graphEquiv₂ f)
state_after: no goals
tactic: simp
Theorem: Filter.isBoundedUnder_ge_sum
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
f : Filter α
inst✝⁴ : f.NeBot
R : Type u_7
inst✝³ : Preorder R
κ : Type u_8
inst✝² : AddCommMonoid R
inst✝¹ : CovariantClass R R (fun a b => a + b) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass R R (fun a b => b + a) fun x x_1 => x ≤ x_1
u : κ → α → R
s : Finset κ
aux : CovariantClass R R (fun a b => a + b) fun x x_1 => x ≥ x_1
⊢ (∀ k ∈ s, IsBoundedUnder (fun x x_1 => x ≥ x_1) f (u k)) → IsBoundedUnder (fun x x_1 => x ≥ x_1) f (∑ k ∈ s, u k)
state_after: no goals
tactic: apply isBoundedUnder_sum (fun _ _ ↦ isBoundedUnder_ge_add) le_rfl
Theorem: List.chain'_append
File: Mathlib/Data/List/Chain.lean

Proof steps:
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a b : α
l : List α
⊢ Chain' R ([] ++ l) ↔ Chain' R [] ∧ Chain' R l ∧ ∀ (x : α), x ∈ [].getLast? → ∀ (y : α), y ∈ l.head? → R x y
state_after: no goals
tactic: simp
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b a : α
l : List α
⊢ Chain' R ([a] ++ l) ↔ Chain' R [a] ∧ Chain' R l ∧ ∀ (x : α), x ∈ [a].getLast? → ∀ (y : α), y ∈ l.head? → R x y
state_after: no goals
tactic: simp [chain'_cons', and_comm]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁✝ l₂✝ : List α
a✝ b✝ a b : α
l₁ l₂ : List α
⊢ Chain' R (a :: b :: l₁ ++ l₂) ↔
    Chain' R (a :: b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ (a :: b :: l₁).getLast? → ∀ (y : α), y ∈ l₂.head? → R x y
state_after: α : Type u
β : Type v
R r : α → α → Prop
l l₁✝ l₂✝ : List α
a✝ b✝ a b : α
l₁ l₂ : List α
⊢ (R a b ∧ Chain' R (b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ (b :: l₁).getLast? → ∀ (y : α), y ∈ l₂.head? → R x y) ↔
    R a b ∧ Chain' R (b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ (a :: b :: l₁).getLast? → ∀ (y : α), y ∈ l₂.head? → R x y
tactic: rw [cons_append, cons_append, chain'_cons, chain'_cons, ← cons_append, chain'_append,
      and_assoc]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁✝ l₂✝ : List α
a✝ b✝ a b : α
l₁ l₂ : List α
⊢ (R a b ∧ Chain' R (b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ (b :: l₁).getLast? → ∀ (y : α), y ∈ l₂.head? → R x y) ↔
    R a b ∧ Chain' R (b :: l₁) ∧ Chain' R l₂ ∧ ∀ (x : α), x ∈ (a :: b :: l₁).getLast? → ∀ (y : α), y ∈ l₂.head? → R x y
state_after: no goals
tactic: simp
Theorem: mem_const_vsub_affineSegment
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z p : P
⊢ p -ᵥ z ∈ affineSegment R (p -ᵥ x) (p -ᵥ y) ↔ z ∈ affineSegment R x y
state_after: no goals
tactic: rw [← affineSegment_const_vsub_image, (vsub_right_injective p).mem_set_image]
Theorem: IsCyclotomicExtension.discr_prime_pow_eq_unit_mul_pow
File: Mathlib/NumberTheory/Cyclotomic/Discriminant.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
L : Type v
ζ : L
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension {p ^ k} K L
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
hirr : Irreducible (cyclotomic (↑(p ^ k)) K)
⊢ ∃ u n, discr K ⇑(IsPrimitiveRoot.powerBasis K hζ).basis = ↑↑u * ↑↑p ^ n
state_after: p : ℕ+
k : ℕ
K : Type u
L : Type v
ζ : L
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension {p ^ k} K L
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
hirr : Irreducible (cyclotomic (↑(p ^ k)) K)
⊢ ∃ u n, (-1) ^ (φ (↑p ^ k) / 2) * ↑↑p ^ (↑p ^ (k - 1) * ((↑p - 1) * k - 1)) = ↑↑u * ↑↑p ^ n
tactic: rw [discr_prime_pow hζ hirr]
state_before: p : ℕ+
k : ℕ
K : Type u
L : Type v
ζ : L
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension {p ^ k} K L
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
hirr : Irreducible (cyclotomic (↑(p ^ k)) K)
⊢ ∃ u n, (-1) ^ (φ (↑p ^ k) / 2) * ↑↑p ^ (↑p ^ (k - 1) * ((↑p - 1) * k - 1)) = ↑↑u * ↑↑p ^ n
state_after: case pos
p : ℕ+
k : ℕ
K : Type u
L : Type v
ζ : L
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension {p ^ k} K L
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
hirr : Irreducible (cyclotomic (↑(p ^ k)) K)
heven : Even (φ (↑p ^ k) / 2)
⊢ ∃ u n, (-1) ^ (φ (↑p ^ k) / 2) * ↑↑p ^ (↑p ^ (k - 1) * ((↑p - 1) * k - 1)) = ↑↑u * ↑↑p ^ n

case neg
p : ℕ+
k : ℕ
K : Type u
L : Type v
ζ : L
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension {p ^ k} K L
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
hirr : Irreducible (cyclotomic (↑(p ^ k)) K)
heven : ¬Even (φ (↑p ^ k) / 2)
⊢ ∃ u n, (-1) ^ (φ (↑p ^ k) / 2) * ↑↑p ^ (↑p ^ (k - 1) * ((↑p - 1) * k - 1)) = ↑↑u * ↑↑p ^ n
tactic: by_cases heven : Even ((p ^ k : ℕ).totient / 2)
Theorem: Subring.coe_iSup_of_directed
File: Mathlib/Algebra/Ring/Subring/Basic.lean

Proof steps:
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S✝
inst✝ : Ring T
ι : Sort u_1
hι : Nonempty ι
S : ι → Subring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
⊢ x ∈ ↑(⨆ i, S i) ↔ x ∈ ⋃ i, ↑(S i)
state_after: no goals
tactic: simp [mem_iSup_of_directed hS]
Theorem: AddSubgroup.card_quotient_dvd_card
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s✝ t s : Subgroup α
⊢ Nat.card (α ⧸ s) ∣ Nat.card α
state_after: no goals
tactic: simp [card_eq_card_quotient_mul_card_subgroup s, @dvd_mul_right ℕ]
Theorem: finRotate_of_lt
File: Mathlib/Logic/Equiv/Fin.lean

Proof steps:
state_before: m n k : ℕ
h : k < n
⊢ (finRotate (n + 1)) ⟨k, ⋯⟩ = ⟨k + 1, ⋯⟩
state_after: case h
m n k : ℕ
h : k < n
⊢ ↑((finRotate (n + 1)) ⟨k, ⋯⟩) = ↑⟨k + 1, ⋯⟩
tactic: ext
state_before: case h
m n k : ℕ
h : k < n
⊢ ↑((finRotate (n + 1)) ⟨k, ⋯⟩) = ↑⟨k + 1, ⋯⟩
state_after: case h
m n k : ℕ
h : k < n
⊢ ↑(finAddFlip ⟨k, ⋯⟩) = k + 1
tactic: dsimp [finRotate_succ]
state_before: case h
m n k : ℕ
h : k < n
⊢ ↑(finAddFlip ⟨k, ⋯⟩) = k + 1
state_after: no goals
tactic: simp [finAddFlip_apply_mk_left h, Nat.add_comm]
Theorem: nhds_nhdsAdjoint_same
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u
β : Type v
a : α
f : Filter α
⊢ 𝓝 a = pure a ⊔ f
state_after: α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
⊢ 𝓝 a = pure a ⊔ f
tactic: let _ := nhdsAdjoint a f
state_before: α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
⊢ 𝓝 a = pure a ⊔ f
state_after: case a
α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
⊢ 𝓝 a ≤ pure a ⊔ f

case a
α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
⊢ pure a ⊔ f ≤ 𝓝 a
tactic: apply le_antisymm
Theorem: Set.card_prod_singleton
File: Mathlib/SetTheory/Cardinal/Finite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s : Set α
b : β
⊢ Nat.card ↑(s ×ˢ {b}) = Nat.card ↑s
state_after: no goals
tactic: rw [prod_singleton, Nat.card_image_of_injective (Prod.mk.inj_right b)]
Theorem: Nat.set_eq_univ
File: Mathlib/Data/Nat/Order/Lemmas.lean

Proof steps:
state_before: a b m n k : ℕ
S : Set ℕ
⊢ S = Set.univ → 0 ∈ S ∧ ∀ k ∈ S, k + 1 ∈ S
state_after: a b m n k : ℕ
⊢ 0 ∈ Set.univ ∧ ∀ k ∈ Set.univ, k + 1 ∈ Set.univ
tactic: rintro rfl
state_before: a b m n k : ℕ
⊢ 0 ∈ Set.univ ∧ ∀ k ∈ Set.univ, k + 1 ∈ Set.univ
state_after: no goals
tactic: simp
Theorem: closedBall_one_mul_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ closedBall 1 δ * {x} = closedBall x δ
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Pi.comapEvalIsoEval_inv_app
File: Mathlib/CategoryTheory/Pi/Basic.lean

Proof steps:
state_before: I : Type w₀
J✝ : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
J : Type w₁
K : Type w₂
h : J → I
j : J
⊢ ∀ {X Y : (i : I) → C i} (f : X ⟶ Y),
    (comap C h ⋙ eval (C ∘ h) j).map f ≫ ((fun f => Iso.refl ((comap C h ⋙ eval (C ∘ h) j).obj f)) Y).hom =
      ((fun f => Iso.refl ((comap C h ⋙ eval (C ∘ h) j).obj f)) X).hom ≫ (eval C (h j)).map f
state_after: I : Type w₀
J✝ : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
J : Type w₁
K : Type w₂
h : J → I
j : J
⊢ ∀ {X Y : (i : I) → C i} (f : X ⟶ Y),
    (comap C h ⋙ eval (C ∘ h) j).map f ≫ 𝟙 ((comap C h ⋙ eval (C ∘ h) j).obj Y) =
      𝟙 ((comap C h ⋙ eval (C ∘ h) j).obj X) ≫ (eval C (h j)).map f
tactic: simp only [Iso.refl]
state_before: I : Type w₀
J✝ : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
J : Type w₁
K : Type w₂
h : J → I
j : J
⊢ ∀ {X Y : (i : I) → C i} (f : X ⟶ Y),
    (comap C h ⋙ eval (C ∘ h) j).map f ≫ 𝟙 ((comap C h ⋙ eval (C ∘ h) j).obj Y) =
      𝟙 ((comap C h ⋙ eval (C ∘ h) j).obj X) ≫ (eval C (h j)).map f
state_after: no goals
tactic: aesop_cat
Theorem: compare_ge_iff_ge
File: Mathlib/Order/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b ≠ Ordering.lt ↔ a ≥ b
state_after: case lt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.lt
⊢ a < b

case eq
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.eq
⊢ b ≤ a

case gt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.gt
⊢ b ≤ a
tactic: cases h : compare a b <;> simp
Theorem: SSet.standardSimplex.map_apply
File: Mathlib/AlgebraicTopology/SimplicialSet.lean

Proof steps:
state_before: m₁ m₂ : SimplexCategoryᵒᵖ
f : m₁ ⟶ m₂
n : SimplexCategory
x : (standardSimplex.obj n).obj m₁
⊢ (standardSimplex.obj n).map f x = (objEquiv n m₂).symm (f.unop ≫ (objEquiv n m₁) x)
state_after: no goals
tactic: rfl
Theorem: TopCat.snd_iso_of_left_embedding_range_subset
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ⇑f
g : Y ⟶ S
H : Set.range ⇑g ⊆ Set.range ⇑f
⊢ IsIso (pullback.snd f g)
state_after: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ⇑f
g : Y ⟶ S
H : Set.range ⇑g ⊆ Set.range ⇑f
esto : ↑(pullback f g) ≃ₜ ↑Y :=
  (Homeomorph.ofEmbedding ⇑(pullback.snd f g) ⋯).trans
    { toFun := Subtype.val, invFun := fun x => ⟨x, ⋯⟩, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
      continuous_invFun := ⋯ }
⊢ IsIso (pullback.snd f g)
tactic: let esto : (pullback f g : TopCat) ≃ₜ Y :=
    (Homeomorph.ofEmbedding _ (snd_embedding_of_left_embedding hf g)).trans
      { toFun := Subtype.val
        invFun := fun x =>
          ⟨x, by
            rw [pullback_snd_range]
            exact ⟨_, (H (Set.mem_range_self x)).choose_spec⟩⟩
        left_inv := fun ⟨_, _⟩ => rfl
        right_inv := fun x => rfl }
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ⇑f
g : Y ⟶ S
H : Set.range ⇑g ⊆ Set.range ⇑f
esto : ↑(pullback f g) ≃ₜ ↑Y :=
  (Homeomorph.ofEmbedding ⇑(pullback.snd f g) ⋯).trans
    { toFun := Subtype.val, invFun := fun x => ⟨x, ⋯⟩, left_inv := ⋯, right_inv := ⋯, continuous_toFun := ⋯,
      continuous_invFun := ⋯ }
⊢ IsIso (pullback.snd f g)
state_after: no goals
tactic: convert (isoOfHomeo esto).isIso_hom
Theorem: Cardinal.nat_eq_ofENat
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: m : ℕ
n : ℕ∞
⊢ ↑m = ↑n ↔ ↑m = n
state_after: no goals
tactic: norm_cast
Theorem: le_update_self_iff
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Preorder (π i)
x y : (i : ι) → π i
i : ι
a b : π i
⊢ x ≤ update x i a ↔ x i ≤ a
state_after: no goals
tactic: simp [le_update_iff]
Theorem: Ordinal.isOpen_iff
File: Mathlib/SetTheory/Ordinal/Topology.lean

Proof steps:
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
⊢ IsOpen s ↔ ∀ o ∈ s, o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s
state_after: s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
⊢ s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s
tactic: refine isOpen_iff_mem_nhds.trans <| forall₂_congr fun o ho => ?_
state_before: s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
⊢ s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s
state_after: case pos
s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
ho' : o.IsLimit
⊢ s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s

case neg
s : Set Ordinal.{u}
a o : Ordinal.{u}
ho : o ∈ s
ho' : ¬o.IsLimit
⊢ s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s
tactic: by_cases ho' : IsLimit o
Theorem: derivWithin_Ioi_eq_Ici
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E✝ : Type w
inst✝³ : NormedAddCommGroup E✝
inst✝² : NormedSpace 𝕜 E✝
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
x : ℝ
⊢ derivWithin f (Ioi x) x = derivWithin f (Ici x) x
state_after: case pos
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E✝ : Type w
inst✝³ : NormedAddCommGroup E✝
inst✝² : NormedSpace 𝕜 E✝
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
x : ℝ
H : DifferentiableWithinAt ℝ f (Ioi x) x
⊢ derivWithin f (Ioi x) x = derivWithin f (Ici x) x

case neg
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E✝ : Type w
inst✝³ : NormedAddCommGroup E✝
inst✝² : NormedSpace 𝕜 E✝
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
x : ℝ
H : ¬DifferentiableWithinAt ℝ f (Ioi x) x
⊢ derivWithin f (Ioi x) x = derivWithin f (Ici x) x
tactic: by_cases H : DifferentiableWithinAt ℝ f (Ioi x) x
Theorem: Fintype.sum_eq_zero_iff_of_nonneg
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : Fintype ι
inst✝ : OrderedCommMonoid M
f : ι → M
hf : 1 ≤ f
⊢ (∀ i ∈ Finset.univ, f i = 1) ↔ f = 1
state_after: no goals
tactic: simp [Function.funext_iff]
Theorem: writtenInExtChartAt_chartAt_symm_comp
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : TopologicalSpace H
inst✝⁷ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : TopologicalSpace H'
inst✝³ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝² : ChartedSpace H M
inst✝¹ : ChartedSpace H' M'
inst✝ : ChartedSpace H H'
x : M'
y : E
hy : y ∈ (extChartAt I x).target
⊢ writtenInExtChartAt I I (↑(chartAt H' x) x) (↑(chartAt H' x).symm) y = y
state_after: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : TopologicalSpace H
inst✝⁷ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : TopologicalSpace H'
inst✝³ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝² : ChartedSpace H M
inst✝¹ : ChartedSpace H' M'
inst✝ : ChartedSpace H H'
x : M'
y : E
hy : y ∈ (extChartAt I x).target
this : ChartedSpace H M' := ChartedSpace.comp H H' M'
⊢ writtenInExtChartAt I I (↑(chartAt H' x) x) (↑(chartAt H' x).symm) y = y
tactic: letI := ChartedSpace.comp H H' M'
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : TopologicalSpace H
inst✝⁷ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : TopologicalSpace H'
inst✝³ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝² : ChartedSpace H M
inst✝¹ : ChartedSpace H' M'
inst✝ : ChartedSpace H H'
x : M'
y : E
hy : y ∈ (extChartAt I x).target
this : ChartedSpace H M' := ChartedSpace.comp H H' M'
⊢ writtenInExtChartAt I I (↑(chartAt H' x) x) (↑(chartAt H' x).symm) y = y
state_after: no goals
tactic: simp_all only [mfld_simps, chartAt_comp]
Theorem: Finset.inr_mem_sumLift₂
File: Mathlib/Data/Sum/Interval.lean

Proof steps:
state_before: α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₂ : γ₂
⊢ inr c₂ ∈ sumLift₂ f g a b ↔ ∃ a₂ b₂, a = inr a₂ ∧ b = inr b₂ ∧ c₂ ∈ g a₂ b₂
state_after: α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₂ : γ₂
⊢ (∃ a₂ b₂ c₂_1, a = inr a₂ ∧ b = inr b₂ ∧ inr c₂ = inr c₂_1 ∧ c₂_1 ∈ g a₂ b₂) ↔
    ∃ a₂ b₂, a = inr a₂ ∧ b = inr b₂ ∧ c₂ ∈ g a₂ b₂

α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₂ : γ₂
⊢ ¬∃ a₁ b₁ c₁, a = inl a₁ ∧ b = inl b₁ ∧ inr c₂ = inl c₁ ∧ c₁ ∈ f a₁ b₁
tactic: rw [mem_sumLift₂, or_iff_right]
state_before: α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₂ : γ₂
⊢ ¬∃ a₁ b₁ c₁, a = inl a₁ ∧ b = inl b₁ ∧ inr c₂ = inl c₁ ∧ c₁ ∈ f a₁ b₁
state_after: case intro.intro.intro.intro.intro.intro
α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₂✝ : γ₂
w✝¹ : α₁
w✝ : β₁
c₂ : γ₁
left✝¹ : a = inl w✝¹
left✝ : b = inl w✝
h : inr c₂✝ = inl c₂
right✝ : c₂ ∈ f w✝¹ w✝
⊢ False
tactic: rintro ⟨_, _, c₂, _, _, h, _⟩
state_before: case intro.intro.intro.intro.intro.intro
α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₂✝ : γ₂
w✝¹ : α₁
w✝ : β₁
c₂ : γ₁
left✝¹ : a = inl w✝¹
left✝ : b = inl w✝
h : inr c₂✝ = inl c₂
right✝ : c₂ ∈ f w✝¹ w✝
⊢ False
state_after: no goals
tactic: exact inr_ne_inl h
Theorem: Submodule.mem_of_span_top_of_smul_mem
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
M : Type v
M'✝ : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'✝
inst✝ : Module R M'✝
I J : Ideal R
N P : Submodule R M
S : Set R
T : Set M
M' : Submodule R M
s : Set R
hs : Ideal.span s = ⊤
x : M
H : ∀ (r : ↑s), ↑r • x ∈ M'
⊢ x ∈ M'
state_after: R : Type u
M : Type v
M'✝ : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'✝
inst✝ : Module R M'✝
I J : Ideal R
N P : Submodule R M
S : Set R
T : Set M
M' : Submodule R M
s : Set R
hs : Ideal.span s = ⊤
x : M
H : ∀ (r : ↑s), ↑r • x ∈ M'
⊢ ⊤ • span R {x} ≤ M'
tactic: suffices (⊤ : Ideal R) • span R ({x} : Set M) ≤ M' by
    rw [top_smul] at this
    exact this (subset_span (Set.mem_singleton x))
state_before: R : Type u
M : Type v
M'✝ : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'✝
inst✝ : Module R M'✝
I J : Ideal R
N P : Submodule R M
S : Set R
T : Set M
M' : Submodule R M
s : Set R
hs : Ideal.span s = ⊤
x : M
H : ∀ (r : ↑s), ↑r • x ∈ M'
⊢ ⊤ • span R {x} ≤ M'
state_after: R : Type u
M : Type v
M'✝ : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'✝
inst✝ : Module R M'✝
I J : Ideal R
N P : Submodule R M
S : Set R
T : Set M
M' : Submodule R M
s : Set R
hs : Ideal.span s = ⊤
x : M
H : ∀ (r : ↑s), ↑r • x ∈ M'
⊢ ⋃ s_1 ∈ s, ⋃ t ∈ {x}, {s_1 • t} ⊆ ↑M'
tactic: rw [← hs, span_smul_span, span_le]
state_before: R : Type u
M : Type v
M'✝ : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'✝
inst✝ : Module R M'✝
I J : Ideal R
N P : Submodule R M
S : Set R
T : Set M
M' : Submodule R M
s : Set R
hs : Ideal.span s = ⊤
x : M
H : ∀ (r : ↑s), ↑r • x ∈ M'
⊢ ⋃ s_1 ∈ s, ⋃ t ∈ {x}, {s_1 • t} ⊆ ↑M'
state_after: no goals
tactic: simpa using H
Theorem: Set.image_val_subset
File: Mathlib/Data/Set/Functor.lean

Proof steps:
state_before: α β✝ : Type u
s : Set α
f : α → Set β✝
g : Set (α → β✝)
β : Set α
γ : Set ↑β
a : α
⊢ ↑γ ⊆ β
state_after: case intro.mk.intro
α β✝ : Type u
s : Set α
f : α → Set β✝
g : Set (α → β✝)
β : Set α
γ : Set ↑β
a val✝ : α
ha : val✝ ∈ β
left✝ : ⟨val✝, ha⟩ ∈ γ
⊢ ↑⟨val✝, ha⟩ ∈ β
tactic: rintro _ ⟨⟨_, ha⟩, _, rfl⟩
state_before: case intro.mk.intro
α β✝ : Type u
s : Set α
f : α → Set β✝
g : Set (α → β✝)
β : Set α
γ : Set ↑β
a val✝ : α
ha : val✝ ∈ β
left✝ : ⟨val✝, ha⟩ ∈ γ
⊢ ↑⟨val✝, ha⟩ ∈ β
state_after: no goals
tactic: exact ha
Theorem: toDual_compares_toDual
File: Mathlib/Order/Compare.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
o : Ordering
⊢ o.Compares (toDual a) (toDual b) ↔ o.Compares b a
state_after: case lt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ lt.Compares (toDual a) (toDual b) ↔ lt.Compares b a

case eq
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ eq.Compares (toDual a) (toDual b) ↔ eq.Compares b a

case gt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ gt.Compares (toDual a) (toDual b) ↔ gt.Compares b a
tactic: cases o
state_before: case lt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ lt.Compares (toDual a) (toDual b) ↔ lt.Compares b a

case eq
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ eq.Compares (toDual a) (toDual b) ↔ eq.Compares b a

case gt
α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
⊢ gt.Compares (toDual a) (toDual b) ↔ gt.Compares b a
state_after: no goals
tactic: exacts [Iff.rfl, eq_comm, Iff.rfl]
Theorem: InnerProductGeometry.sin_angle_add_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ Real.sin (angle x (x + y)) = ‖y‖ / ‖x + y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ ‖y‖ ≤ ‖x + y‖
tactic: rw [angle_add_eq_arcsin_of_inner_eq_zero h h0,
    Real.sin_arcsin (le_trans (by norm_num) (div_nonneg (norm_nonneg _) (norm_nonneg _)))
      (div_le_one_of_le _ (norm_nonneg _))]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ ‖y‖ ≤ ‖x + y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ ‖y‖ * ‖y‖ ≤ ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖
tactic: rw [mul_self_le_mul_self_iff (norm_nonneg _) (norm_nonneg _),
    norm_add_sq_eq_norm_sq_add_norm_sq_real h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0 ∨ y ≠ 0
⊢ ‖y‖ * ‖y‖ ≤ ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖
state_after: no goals
tactic: exact le_add_of_nonneg_left (mul_self_nonneg _)