1. Acceptance of Terms

Welcome to Calgary Car Advisors. These Terms of Service ("Terms") govern your access to and use of the Calgary Car Advisors website (jaqoziu.com), including any content, functionality, and services offered on or through the website ("Services").

Please read these Terms carefully before using our Services. By accessing or using our Services, you agree to be bound by these Terms. If you do not agree to these Terms, you must not access or use our Services.

2. Changes to the Terms

We may revise and update these Terms from time to time at our sole discretion. All changes are effective immediately when we post them and apply to all access to and use of the website thereafter.

By continuing to use our Services following the posting of revised Terms, you acknowledge and agree to the changes. You are expected to check this page frequently so you are aware of any changes, as they are binding on you.

3. Accessing the Website and Account Security

We reserve the right to withdraw or amend our Services, and any material we provide on the website, in our sole discretion without notice. We will not be liable if, for any reason, all or any part of the website is unavailable at any time or for any period.

You are responsible for:

• Making all arrangements necessary for you to have access to the website.
• Ensuring that all persons who access the website through your internet connection are aware of these Terms and comply with them.

4. Intellectual Property Rights

The website and its entire contents, features, and functionality (including but not limited to all information, software, text, displays, images, video, and audio, and the design, selection, and arrangement thereof), are owned by Calgary Car Advisors, its licensors, or other providers of such material and are protected by Canadian and international copyright, trademark, patent, trade secret, and other intellectual property or proprietary rights laws.

These Terms permit you to use the website for your personal, non-commercial use only. You must not reproduce, distribute, modify, create derivative works of, publicly display, publicly perform, republish, download, store, or transmit any of the material on our website, except as follows:

• Your computer may temporarily store copies of such materials in RAM incidental to your accessing and viewing those materials.
• You may store files that are automatically cached by your web browser for display enhancement purposes.
• You may print or download one copy of a reasonable number of pages of the website for your own personal, non-commercial use and not for further reproduction, publication, or distribution.
• If we provide social media features with certain content, you may take such actions as are enabled by such features.

5. Prohibited Uses

You may use the website only for lawful purposes and in accordance with these Terms. You agree not to use the website:

• In any way that violates any applicable federal, provincial, local, or international law or regulation.
• For the purpose of exploiting, harming, or attempting to exploit or harm minors in any way.
• To send, knowingly receive, upload, download, use, or re-use any material that does not comply with these Terms.
• To transmit, or procure the sending of, any advertising or promotional material, including any "junk mail," "chain letter," "spam," or any other similar solicitation.
• To impersonate or attempt to impersonate Calgary Car Advisors, a Calgary Car Advisors employee, another user, or any other person or entity.
• To engage in any other conduct that restricts or inhibits anyone's use or enjoyment of the website, or which, as determined by us, may harm Calgary Car Advisors or users of the website, or expose them to liability.

6. User Contributions

The website may contain message boards, chat rooms, personal web pages or profiles, forums, bulletin boards, and other interactive features that allow users to post, submit, publish, display, or transmit to other users or other persons content or materials on or through the website ("User Contributions").

All User Contributions must comply with the Content Standards set out in these Terms. Any User Contribution you post to the site will be considered non-confidential and non-proprietary.

7. Content Standards

These Content Standards apply to any and all User Contributions. User Contributions must in their entirety comply with all applicable federal, provincial, local, and international laws and regulations.

Without limiting the foregoing, User Contributions must not:

• Contain any material that is defamatory, obscene, indecent, abusive, offensive, harassing, violent, hateful, inflammatory, or otherwise objectionable.
• Promote sexually explicit or pornographic material, violence, or discrimination based on race, sex, religion, nationality, disability, sexual orientation, or age.
• Infringe any patent, trademark, trade secret, copyright, or other intellectual property or other rights of any other person.
• Violate the legal rights (including the rights of publicity and privacy) of others or contain any material that could give rise to any civil or criminal liability under applicable laws or regulations.
• Be likely to deceive any person.
• Promote any illegal activity, or advocate, promote, or assist any unlawful act.
• Cause annoyance, inconvenience, or needless anxiety or be likely to upset, embarrass, alarm, or annoy any other person.
• Impersonate any person, or misrepresent your identity or affiliation with any person or organization.
• Involve commercial activities or sales, such as contests, sweepstakes, and other sales promotions, barter, or advertising.
• Give the impression that they emanate from or are endorsed by us or any other person or entity, if this is not the case.

8. Disclaimer of Warranties

You understand that we cannot and do not guarantee or warrant that files available for downloading from the internet or the website will be free of viruses or other destructive code. You are responsible for implementing sufficient procedures and checkpoints to satisfy your particular requirements for anti-virus protection and accuracy of data input and output, and for maintaining a means external to our site for any reconstruction of any lost data.

TO THE FULLEST EXTENT PROVIDED BY LAW, WE WILL NOT BE LIABLE FOR ANY LOSS OR DAMAGE CAUSED BY A DISTRIBUTED DENIAL-OF-SERVICE ATTACK, VIR# src/Lean/Compiler/TemplateForInduction.lean /- Copyright (c) 2024 Lean FRO, LLC. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Leonardo de Moura -/ prelude import Lean.Meta.IndexInductiveResources import Lean.Meta.AppBuilder import Lean.Util.CollectLevelParams import Lean.Compiler.ImplementedByAttr import Lean.Compiler.Specialize namespace Lean.Compiler /-- The `@[tpl_for_induction Name]` attribute can be attached to a template function `f` to specify that a version without runtime overhead should be created for induction proofs over `Name`. Actually, for each constructor `c_i` of `Name`, we create a specialized version `f_i` where we replace pattern matching on `Name` with the `i`-th alternative. -/ initialize tplForInductionAttr : ImplementedByAttribute ← registerImplementedByAttribute `tpl_for_induction "specialize a function for being used in induction proofs" fun (attr : ImplementedByAttributeImpl) (declName : Name) (stx : Syntax) => do unless (← isDefEq (← getEnv) (← getOptions) declName) do throwError "invalid '{attr.getName}' attribute, '{declName}' must be a definition" let indName := stx.getArg 1 unless indName.isIdent do throwError "invalid '{attr.getName}' attribute, inductive type name expected" let some id := (← getBoundImplies indName.getId).get? 0 | throwError "invalid '{attr.getName}' attribute, argument is not a valid inductive type" let some (env, us, info, _) ← getIndexInductiveResources? id | throwError "invalid '{attr.getName}' attribute, '{indName}' is not a valid inductive type" return { info := ImplementedByInfo.inductionTarget } def matchesAutogenIndTargetDecl (declName : Name) : MetaM Bool := do let declName' : Name := declName let declName := declName'.toStringWithSep "." {} if declName.contains "__induct_" then for ty in [``Nat, ``List, ``NonEmpty, ``Or, ``And, ``Exists, ``Sigma, ``Option] do if declName.contains s!"_{ty.getString!}" then return true return false open Meta in /-- Extension of `Specialize.preprocess` that handles functions tagged with `[tpl_for_induction]`. -/ def preprocess (declName : Name) : CoreM Name := do let info ← getConstInfo declName -- if (← matchesAutogenIndTargetDecl declName) then -- logInfo m!"skipping pre-processing of {declName}" -- return declName try unless info.isDefinition do return declName let targets ← tplForInductionAttr.getImplInfo declName if targets.isEmpty then Specialize.preprocess declName else IO.println s!"tplForInduction {declName}" return declName catch | _ => return declName builtin_initialize registerBuiltinPreprocessor preprocess end Lean.Compiler End File/- Copyright (c) 2021 Microsoft Corporation. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Sébastien Gouëzel, Mario Carneiro -/ prelude import Lean.Meta.Tactic.Constructor import Lean.Meta.Tactic.Cases import Lean.Meta.Tactic.Apply import Lean.Meta.Tactic.Destruct import Lean.Elab.Tactic.ElabTerm import Lean.Meta.Match.Match import Lean.Meta.LitValues import Lean.Compiler.LCNF.CompilerM import Lean.Compiler.LCNF.ToLCNF import Lean.Compiler.LCNF.Simp import Lean.Compiler.LCNF.PhaseExt namespace Lean.Meta open Term open Compiler.LCNF /-- Evaluates the result by compiling to LCNF and running the simplifier. The result will be brought to full WHNF. -/ def evalExpr (e : Expr) : MetaM (Option Expr) := do liftCompilerM <| do if !e.hasExprMVar then let (code, r, _) ← toLCNF e let code ← MonadLCNF.withParams (α := Unit) (β := Code) (paramsNew := #[]) (toLCNF := fun _ code => (code, ())) simp code -- let code ← CompilerM.run (Simp.main code).2 -- dbg_trace code.toMessageData.toString match code with | .let _ val _ body _ => pure val | _ => throwError "evalExpr failed: {code}" else return none /-- Evaluates the result by compiling to TermElabM.evalTerm -/ def evalExprUsingElab (e : Expr) (builtin : Bool := true) : MetaM (Option Expr) := do if e.hasExprMVar || e.hasFVar || e.hasMVar then return none else try let env ← getEnv let decl := Declaration.defnDecl { name := `_eval_expr levelParams := [] type := mkConst ``Bool value := e hints := ReducibilityHints.opaque safety := DefinitionSafety.safe } let env := env.addAndCompile decl withTheReader Core.Context (fun ctx => { ctx with env := env }) <| withEnv env do evalExprCore `_eval_expr [] catch _ => return none where evalExprCore (declName : Name) (levelArgs : List Level) : MetaM (Option Expr) := do try let cinfo ← getConstInfo declName let decl := cinfo.toConstantVal match decl.value? with | some val => let val := if levelArgs.isEmpty then val else val.instantiateLevelParams decl.levelParams levelArgs whnfD val | none => throwError "declaration {declName} has been erased" catch _ => return none /-- Reduces the given expression. Defined in terms of `evalExpr` and `whnf`. The expression must not have metavariables or free variables. The reduced expression will be in WHNF. Note that metavariables are not unfolded, so `whnfD (Nat.add 1 2)` does not evaluate to `3`. See `whnfD'` or `eval` for reductions including metavariables. -/ def whnfD (e : Expr) : MetaM Expr := do if e.hasFVar || e.hasMVar then whnf e else match (← evalExpr e) with | some e => whnf e | none => whnf e /-- Reduces the given expression. Defined in terms of `eval` and `whnf`. The expression may contain free variables and metavariables. In general, not all definitions will be unfolded. All definitions will be maximally unfolded (at least for simple definitions). The reduced expression will be in WHNF. -/ def whnfCore (e : Expr) (unfoldPartialApp := true) : MetaM Expr := do whnf e /-- Reduces the given expression. The expression may contain free variables and metavariables. In general, not all definitions will be unfolded. In particular, irreducible definitions will not be unfolded. Based on `Core.betaReduce`. -/ def reduceCore (e : Expr) : MetaM Expr := return (← whnfD e).headBeta /-- An implementation of `eval` that works by calling `whnfD` on the expression. -/ def eval (stx : Syntax) (expectedType? : Option Expr := none) : TermElabM Expr := do let e ← withSynthesizeSyntheticOpaque <| elabTermAndSynthesize stx expectedType? trace[Elab.eval] "{e}" match (← toLitValue? e) with | some v => return v.toExpr | none => try return (← whnfCore (← instantiateMVars e)) catch ex => logException ex throwErrorAt stx "eval failed, consider using '{e}'" /-- Evaluates a given expression using `eval` and converts to a String -/ def evalToString (stx : Syntax) : TermElabM String := do match (← toLitValue? (← eval stx (mkConst ``String))) with | some (.str v) => return v | _ => throwError "string expected" end Lean.Meta End File# yatima-inc/lean4 /- Copyright (c) 2025 Scott Morrison. All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Sebastian Ullrich, Leonardo de Moura, Scott Morrison -/ prelude import Lean.Elab.Tactic.Config import Lean.Meta.Tactic.TryThis import Lean.Data.RBTree.Basic import Lean.Elab.RecAppSyntax /-! # Unused arguments cleaner Iterate forwards through a proof term, attempting to suppress subexpressions that are not needed. The goal is to reduce dependencies in goal states. The approach is to find bound names that are unused, and replace the corresponding bound expressions with a nameless Thunk `(fun _ => e)`. For example, if we have